@strkfarm/sdk 1.1.70 → 2.0.0-dev.2

package/src/modules/ExtendedWrapperSDk/types.ts

@@ -0,0 +1,311 @@
+/**
+ * TypeScript type definitions for Extended Exchange API
+ * Based on Python SDK models from x10.perpetual
+ */
+
+// Enums
+export enum OrderSide {
+  BUY = "BUY",
+  SELL = "SELL",
+}
+
+export enum TimeInForce {
+  GTT = "GTT",
+  IOC = "IOC",
+  FOK = "FOK",
+}
+
+export enum OrderType {
+  LIMIT = "LIMIT",
+  CONDITIONAL = "CONDITIONAL",
+  MARKET = "MARKET",
+  TPSL = "TPSL",
+}
+
+export enum OrderStatus {
+  UNKNOWN = "UNKNOWN",
+  NEW = "NEW",
+  UNTRIGGERED = "UNTRIGGERED",
+  PARTIALLY_FILLED = "PARTIALLY_FILLED",
+  FILLED = "FILLED",
+  CANCELLED = "CANCELLED",
+  EXPIRED = "EXPIRED",
+  REJECTED = "REJECTED",
+}
+
+export enum OrderStatusReason {
+  UNKNOWN = "UNKNOWN",
+  NONE = "NONE",
+  UNKNOWN_MARKET = "UNKNOWN_MARKET",
+  DISABLED_MARKET = "DISABLED_MARKET",
+  NOT_ENOUGH_FUNDS = "NOT_ENOUGH_FUNDS",
+  NO_LIQUIDITY = "NO_LIQUIDITY",
+  INVALID_FEE = "INVALID_FEE",
+  INVALID_QTY = "INVALID_QTY",
+  INVALID_PRICE = "INVALID_PRICE",
+  INVALID_VALUE = "INVALID_VALUE",
+  UNKNOWN_ACCOUNT = "UNKNOWN_ACCOUNT",
+  SELF_TRADE_PROTECTION = "SELF_TRADE_PROTECTION",
+  POST_ONLY_FAILED = "POST_ONLY_FAILED",
+  REDUCE_ONLY_FAILED = "REDUCE_ONLY_FAILED",
+  INVALID_EXPIRE_TIME = "INVALID_EXPIRE_TIME",
+  POSITION_TPSL_CONFLICT = "POSITION_TPSL_CONFLICT",
+  INVALID_LEVERAGE = "INVALID_LEVERAGE",
+  PREV_ORDER_NOT_FOUND = "PREV_ORDER_NOT_FOUND",
+  PREV_ORDER_TRIGGERED = "PREV_ORDER_TRIGGERED",
+  TPSL_OTHER_SIDE_FILLED = "TPSL_OTHER_SIDE_FILLED",
+  PREV_ORDER_CONFLICT = "PREV_ORDER_CONFLICT",
+  ORDER_REPLACED = "ORDER_REPLACED",
+  POST_ONLY_MODE = "POST_ONLY_MODE",
+  REDUCE_ONLY_MODE = "REDUCE_ONLY_MODE",
+  TRADING_OFF_MODE = "TRADING_OFF_MODE",
+}
+
+export enum PositionSide {
+  LONG = "LONG",
+  SHORT = "SHORT",
+}
+
+export enum ExitType {
+  TRADE = "TRADE",
+  LIQUIDATION = "LIQUIDATION",
+  ADL = "ADL",
+}
+
+export enum AssetOperationType {
+  DEPOSIT = "DEPOSIT",
+  WITHDRAWAL = "WITHDRAWAL",
+  TRANSFER = "TRANSFER",
+}
+
+export enum AssetOperationStatus {
+  PENDING = "PENDING",
+  COMPLETED = "COMPLETED",
+  FAILED = "FAILED",
+}
+
+// Base types
+export interface SettlementSignature {
+  r: string;
+  s: string;
+}
+
+export interface StarkSettlement {
+  signature: SettlementSignature;
+  stark_key: string;
+  collateral_position: string;
+}
+
+export interface StarkDebuggingOrderAmounts {
+  collateral_amount: string;
+  fee_amount: string;
+  synthetic_amount: string;
+}
+
+// Order types
+export interface PlacedOrder {
+  id: number;
+  external_id: string;
+}
+
+export interface OpenOrder {
+  id: number;
+  account_id: number;
+  external_id: string;
+  market: string;
+  type: OrderType;
+  side: OrderSide;
+  status: OrderStatus;
+  status_reason?: OrderStatusReason;
+  price: string;
+  average_price?: string;
+  qty: string;
+  filled_qty?: string;
+  reduce_only: boolean;
+  post_only: boolean;
+  payed_fee?: string;
+  created_time: number;
+  updated_time: number;
+  expiry_time?: number;
+}
+
+// Position types
+export interface Position {
+  id: number;
+  accountId: number;
+  market: string;
+  side: PositionSide;
+  leverage: string;
+  size: string;
+  value: string;
+  openPrice: string;
+  markPrice: string;
+  liquidationPrice?: string;
+  unrealisedPnl: string;
+  realisedPnl: string;
+  tpPrice?: string;
+  slPrice?: string;
+  adl?: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface PositionHistory {
+  id: number;
+  account_id: number;
+  market: string;
+  side: PositionSide;
+  leverage: string;
+  size: string;
+  open_price: string;
+  exit_type?: ExitType;
+  exit_price?: string;
+  realised_pnl: string;
+  created_time: number;
+  closed_time?: number;
+}
+
+// Balance types
+export interface Balance {
+  collateral_name: string;
+  balance: string;
+  equity: string;
+  availableForTrade: string;
+  availableForWithdrawal: string;
+  unrealisedPnl: string;
+  initialMargin: string;
+  marginRatio: string;
+  updatedTime: number;
+}
+
+// Market types
+export interface RiskFactorConfig {
+  upper_bound: string;
+  risk_factor: string;
+}
+
+export interface MarketStats {
+  daily_volume: string;
+  daily_volume_base: string;
+  daily_price_change: string;
+  daily_low: string;
+  daily_high: string;
+  last_price: string;
+  ask_price: string;
+  bid_price: string;
+  mark_price: string;
+  index_price: string;
+  funding_rate: string;
+  next_funding_rate: number;
+  open_interest: string;
+  open_interest_base: string;
+}
+
+export interface TradingConfig {
+  min_order_size: string;
+  min_order_size_change: string;
+  min_price_change: string;
+  max_market_order_value: string;
+  max_limit_order_value: string;
+  max_position_value: string;
+  max_leverage: string;
+  max_num_orders: number;
+  limit_price_cap: string;
+  limit_price_floor: string;
+  risk_factor_config: RiskFactorConfig[];
+}
+
+export interface L2Config {
+  type: string;
+  collateral_id: string;
+  collateral_resolution: number;
+  synthetic_id: string;
+  synthetic_resolution: number;
+}
+
+export interface Market {
+  name: string;
+  asset_name: string;
+  asset_precision: number;
+  collateral_asset_name: string;
+  collateral_asset_precision: number;
+  active: boolean;
+  market_stats: MarketStats;
+  trading_config: TradingConfig;
+  l2_config: L2Config;
+}
+
+// Asset operation types
+export interface AssetOperation {
+  id: number;
+  type: AssetOperationType;
+  status: AssetOperationStatus;
+  amount: string;
+  asset: string;
+  created_time: number;
+  updated_time: number;
+  description?: string;
+  transactionHash?:string;
+}
+
+// Request types
+export interface CreateOrderRequest {
+  market_name: string;
+  amount: string;
+  price: string;
+  side: OrderSide;
+  post_only?: boolean;
+  previous_order_id?: number;
+  external_id?: string;
+  time_in_force?: TimeInForce;
+}
+
+export interface WithdrawRequest {
+  amount: string;
+  asset?: string;
+}
+
+export interface SignedWithdrawRequest {
+  recipient: string;
+  position_id: number;
+  amount: number;
+  expiration: number;
+  salt: number;
+}
+
+export interface CancelOrderRequest {
+  order_id: number;
+}
+
+// Response wrapper type
+export interface ApiResponse<T> {
+  success: boolean;
+  message: string;
+  data: T;
+}
+
+// Extended API response wrapper (matches Python WrappedApiResponse)
+export interface ExtendedApiResponse<T> {
+  status: 'OK' | 'ERROR';
+  message: string;
+  data: T;
+}
+
+// Configuration types
+export interface ExtendedWrapperConfig {
+  baseUrl: string;
+  apiKey?: string;
+  timeout?: number;
+  retries?: number;
+}
+
+export interface UpdateLeverageRequest {
+  leverage: string;
+  market: string;
+}
+
+export interface FundingRate {
+ m: string;
+ f:string;
+ t:number;
+}

package/src/modules/ExtendedWrapperSDk/wrapper.ts

@@ -0,0 +1,395 @@
+/**
+ * ExtendedWrapper - TypeScript wrapper for Extended Exchange API
+ * Provides a clean interface to interact with the Extended Exchange trading API
+ */
+
+import {
+  CreateOrderRequest,
+  WithdrawRequest,
+  SignedWithdrawRequest,
+  CancelOrderRequest,
+  PlacedOrder,
+  OpenOrder,
+  Position,
+  Balance,
+  Market,
+  MarketStats,
+  AssetOperation,
+  ExtendedApiResponse,
+  ExtendedWrapperConfig,
+  OrderSide,
+  TimeInForce,
+  AssetOperationType,
+  AssetOperationStatus,
+  FundingRate,
+  UpdateLeverageRequest,
+} from "./types";
+
+export class ExtendedWrapper {
+  private baseUrl: string;
+  private apiKey?: string;
+  private timeout: number;
+  private retries: number;
+
+  constructor(config: ExtendedWrapperConfig) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, ""); // Remove trailing slash
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout || 30000; // 30 seconds default
+    this.retries = config.retries || 3;
+  }
+
+  /**
+   * Make HTTP request with retry logic and error handling
+   */
+  private async makeRequest<T>(
+    endpoint: string,
+    options: RequestInit = {}
+  ): Promise<ExtendedApiResponse<T>> {
+    const url = `${this.baseUrl}${endpoint}`;
+
+    const headers: Record<string, any> = {
+      "Content-Type": "application/json",
+      ...options.headers,
+    };
+
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+
+    const requestOptions: RequestInit = {
+      ...options,
+      headers,
+      signal: AbortSignal.timeout(this.timeout),
+    };
+
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= this.retries; attempt++) {
+      try {
+        const response = await fetch(url, requestOptions);
+
+        if (!response.ok) {
+          const errorData = await response.json().catch(() => ({}));
+          throw new Error(
+            `HTTP ${response.status}: ${
+              errorData.detail || response.statusText
+            }`
+          );
+        }
+
+        const data = await response.json();
+        return data;
+      } catch (error) {
+        lastError = error as Error;
+
+        if (attempt < this.retries) {
+          // Exponential backoff
+          const delay = Math.pow(2, attempt) * 1000;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+
+    throw lastError || new Error("Request failed after all retries");
+  }
+
+  /**
+   * Create a new order on Extended Exchange
+   */
+  async createOrder(
+    request: CreateOrderRequest
+  ): Promise<ExtendedApiResponse<PlacedOrder>> {
+    return this.makeRequest<PlacedOrder>("/api/v1/orders", {
+      method: "POST",
+      body: JSON.stringify(request),
+    });
+  }
+
+  /**
+   * Get all markets
+   */
+  async getMarkets(
+    marketNames?: string
+  ): Promise<ExtendedApiResponse<Market[]>> {
+    const params = marketNames
+      ? `?market_names=${encodeURIComponent(marketNames)}`
+      : "";
+    return this.makeRequest<Market[]>(`/api/v1/markets${params}`);
+  }
+
+   /**
+   * 
+   * @param orderId - The ID of the order to get
+   * @returns The order
+   */
+   async getOrderByOrderId(orderId: string): Promise<ExtendedApiResponse<OpenOrder>> {
+    const orderIdInt = parseInt(orderId);
+    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderIdInt}`);
+  }
+
+  /**
+   * Get market statistics for a specific market
+   */
+  async getMarketStatistics(
+    marketName: string
+  ): Promise<ExtendedApiResponse<MarketStats>> {
+    return this.makeRequest<MarketStats>(
+      `/api/v1/markets/statistics?market_name=${encodeURIComponent(marketName)}`
+    );
+  }
+
+  /**
+   * Get current trading positions
+   */
+  async getPositions(
+    marketNames?: string
+  ): Promise<ExtendedApiResponse<Position[]>> {
+    const params = marketNames
+      ? `?market_names=${encodeURIComponent(marketNames)}`
+      : "";
+    return this.makeRequest<Position[]>(`/api/v1/positions${params}`);
+  }
+
+  /**
+   * Get account balance and holdings
+   */
+  async getHoldings(): Promise<ExtendedApiResponse<Balance>> {
+    return this.makeRequest<Balance>("/api/v1/holdings");
+  }
+
+  /**
+   * Initiate a withdrawal from Extended Exchange
+   */
+  async withdraw(
+    request: WithdrawRequest
+  ): Promise<ExtendedApiResponse<number>> {
+    return this.makeRequest<number>("/api/v1/withdraw", {
+      method: "POST",
+      body: JSON.stringify(request),
+    });
+  }
+
+  /**
+   * Create and sign a withdrawal request hash
+   */
+  async signWithdrawalRequest(request: SignedWithdrawRequest): Promise<
+    ExtendedApiResponse<{
+      withdraw_request_hash: string;
+      signature: {
+        r: string;
+        s: string;
+      };
+    }>
+  > {
+    return this.makeRequest("/api/v1/withdraw/sign", {
+      method: "POST",
+      body: JSON.stringify(request),
+    });
+  }
+
+  /**
+   * Cancel an existing order
+   */
+  async cancelOrder(
+    request: CancelOrderRequest
+  ): Promise<ExtendedApiResponse<{}>> {
+    return this.makeRequest<{}>("/api/v1/orders/cancel", {
+      method: "POST",
+      body: JSON.stringify(request),
+    });
+  }
+
+
+  /**
+   * Get all open orders
+   */
+  async getOpenOrders(
+    marketName?: string
+  ): Promise<ExtendedApiResponse<OpenOrder[]>> {
+    const endpoint = marketName
+      ? `/api/v1/marketOrders/${marketName}`
+      : "/api/v1/marketOrders";
+    return this.makeRequest<OpenOrder[]>(endpoint,{
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+  }
+
+  /**
+   * Update leverage on the market
+   * @param request
+   * @returns
+   */
+  async updateLeverage(
+    request: UpdateLeverageRequest
+  ): Promise<ExtendedApiResponse<{}>> {
+    return this.makeRequest<{}>("/api/v1/leverage", {
+      method: "POST",
+      body: JSON.stringify(request),
+    });
+  }
+
+  /**
+   * Get asset operations with optional filtering
+   */
+  async getAssetOperations(
+    options: {
+      id?: number;
+      operationsType?: AssetOperationType[];
+      operationsStatus?: AssetOperationStatus[];
+      startTime?: number;
+      endTime?: number;
+      cursor?: number;
+      limit?: number;
+    } = {}
+  ): Promise<ExtendedApiResponse<AssetOperation[]>> {
+    const params = new URLSearchParams();
+
+    if (options.id !== undefined) params.append("id", options.id.toString());
+    if (options.operationsType) {
+      params.append("operations_type", options.operationsType.join(","));
+    }
+    if (options.operationsStatus) {
+      params.append("operations_status", options.operationsStatus.join(","));
+    }
+    if (options.startTime !== undefined)
+      params.append("start_time", options.startTime.toString());
+    if (options.endTime !== undefined)
+      params.append("end_time", options.endTime.toString());
+    if (options.cursor !== undefined)
+      params.append("cursor", options.cursor.toString());
+    if (options.limit !== undefined)
+      params.append("limit", options.limit.toString());
+
+    const queryString = params.toString();
+    const endpoint = `/api/v1/asset-operations${
+      queryString ? `?${queryString}` : ""
+    }`;
+
+    return this.makeRequest<AssetOperation[]>(endpoint);
+  }
+
+  /**
+   * Health check endpoint
+   */
+  async healthCheck(): Promise<ExtendedApiResponse<MarketStats>> {
+    return this.makeRequest<MarketStats>("/api/v1/health");
+  }
+
+  /**
+   * Convenience method to create a buy order
+   */
+  async createBuyOrder(
+    marketName: string,
+    amount: string,
+    price: string,
+    options: {
+      postOnly?: boolean;
+      previousOrderId?: number;
+      externalId?: string;
+      timeInForce?: TimeInForce;
+    } = {}
+  ): Promise<ExtendedApiResponse<PlacedOrder>> {
+    return this.createOrder({
+      market_name: marketName,
+      amount,
+      price,
+      side: OrderSide.BUY,
+      ...options,
+    });
+  }
+
+   /**
+   * Get order by ID
+   * @param orderId - The ID of the order to get
+   * @returns The order
+   */
+   async getOrderById(orderId: number): Promise<ExtendedApiResponse<OpenOrder>> {
+    return this.makeRequest<OpenOrder>(`/api/v1/orderId/${orderId}`);
+  }
+
+  /**
+   * Convenience method to create a sell order
+   */
+  async createSellOrder(
+    marketName: string,
+    amount: string,
+    price: string,
+    options: {
+      postOnly?: boolean;
+      previousOrderId?: number;
+      externalId?: string;
+      timeInForce?: TimeInForce;
+    } = {}
+  ): Promise<ExtendedApiResponse<PlacedOrder>> {
+    return this.createOrder({
+      market_name: marketName,
+      amount,
+      price,
+      side: OrderSide.SELL,
+      ...options,
+    });
+  }
+
+  /**
+   * Get positions for a specific market
+   */
+  async getPositionsForMarket(
+    marketName: string
+  ): Promise<ExtendedApiResponse<Position[]>> {
+    return this.getPositions(marketName);
+  }
+
+  /**
+   * Get open orders for a specific market
+   */
+  async getOpenOrdersForMarket(
+    marketName: string
+  ): Promise<ExtendedApiResponse<OpenOrder[]>> {
+    return this.getOpenOrders(marketName);
+  }
+
+  /**
+   * Cancel order by ID (convenience method)
+   */
+  async cancelOrderById(orderId: number): Promise<ExtendedApiResponse<{}>> {
+    return this.cancelOrder({ order_id: orderId });
+  }
+  
+  /**
+   * Get order history for a specific market
+   * @param marketName - The name of the market to get order history for
+   * @returns The order history for the specified market
+   */
+  async getOrderHistory(marketName: string): Promise<ExtendedApiResponse<OpenOrder[]>> {
+    return this.makeRequest<OpenOrder[]>(`/api/v1/marketOrders/${marketName}`);
+  }
+
+  /**
+   * Withdraw USDC (convenience method)
+   */
+  async withdrawUSDC(amount: string): Promise<ExtendedApiResponse<number>> {
+    return this.withdraw({ amount, asset: "USDC" });
+  }
+
+  /**
+   * Get funding rates for a specific market
+   * @param marketName - The name of the market to get funding rates for
+   * @returns The funding rates for the specified market
+   */
+  async getFundingRates(
+    marketName: string,
+    side: string
+  ): Promise<ExtendedApiResponse<FundingRate[]>> {
+    return this.makeRequest<FundingRate[]>(
+      `/api/v1/markets/funding-rates?market_name=${encodeURIComponent(
+        marketName
+      )}&side=${encodeURIComponent(side)}`
+    );
+  }
+
+}
+
+export default ExtendedWrapper;