@strkfarm/sdk 2.0.0-dev.9 → 2.0.0-staging.2

package/src/modules/ExtendedWrapperSDk/wrapper.ts

@@ -1,395 +0,0 @@
-/**
- * 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;

package/src/modules/midas.ts

@@ -1,159 +0,0 @@
-import axios from 'axios';
-import { ContractAddr } from '../dataTypes';
-import { logger } from '../utils/logger';
-
-/**
- * Midas module for interacting with Midas API
- * Provides functions to get APY, price, and TVL data for Midas tokens
- */
-export class Midas {
-    // Static mapping of contract addresses to Midas API symbols
-    private static readonly CONTRACT_TO_SYMBOL: Record<string, string> = {
-        '0x4e4fb1a9ca7e84bae609b9dc0078ad7719e49187ae7e425bb47d131710eddac': 'mre7btc', // mRe7BTC
-        '0x4be8945e61dc3e19ebadd1579a6bd53b262f51ba89e6f8b0c4bc9a7e3c633fc': 'mre7', // mRe7YIELD
-    };
-
-    private static readonly BASE_URL = 'https://api-prod.midas.app/api/data';
-
-    /**
-     * Check if a contract address is supported by Midas
-     * @param contractAddr The contract address to check
-     * @returns True if the contract address is supported
-     */
-    static isSupported(contractAddr: ContractAddr): boolean {
-        return contractAddr.address in Midas.CONTRACT_TO_SYMBOL;
-    }
-
-    /**
-     * Get the Midas symbol for a given contract address
-     * @param contractAddr The contract address to look up
-     * @returns The Midas symbol for the contract
-     * @throws Error if contract address is not found
-     */
-    static getSymbolFromContract(contractAddr: ContractAddr): string {
-        const symbol = Midas.CONTRACT_TO_SYMBOL[contractAddr.address];
-        if (!symbol) {
-            throw new Error(`Contract address ${contractAddr.address} not found in Midas mapping`);
-        }
-        return symbol;
-    }
-
-    /**
-     * Get APY data for all Midas tokens
-     * @returns Object with token symbols as keys and APY values as numbers
-     * @throws Error if API request fails
-     */
-    static async getAPYs(): Promise<Record<string, number>> {
-        try {
-            const response = await axios.get(`${Midas.BASE_URL}/apys`);
-            return response.data;
-        } catch (error) {
-            logger.error('Failed to fetch APYs from Midas API:', error);
-            throw new Error(`Failed to fetch APYs: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-
-    /**
-     * Get APY for a specific token by contract address
-     * @param contractAddr The contract address of the token
-     * @returns The APY value for the token
-     * @throws Error if contract address not found or API request fails
-     */
-    static async getAPY(contractAddr: ContractAddr): Promise<number> {
-        const symbol = Midas.getSymbolFromContract(contractAddr);
-        const apys = await Midas.getAPYs();
-        
-        if (!(symbol in apys)) {
-            throw new Error(`Symbol ${symbol} not found in APY data`);
-        }
-        
-        return apys[symbol];
-    }
-
-    /**
-     * Get price data for a specific token
-     * @param contractAddr The contract address of the token
-     * @param timestampFrom Optional start timestamp (defaults to 30 days ago)
-     * @param timestampTo Optional end timestamp (defaults to now)
-     * @param environment Environment (defaults to 'mainnet')
-     * @returns The latest price for the token
-     * @throws Error if contract address not found or API request fails
-     */
-    static async getPrice(
-        contractAddr: ContractAddr,
-        timestampFrom?: number,
-        timestampTo?: number,
-        environment: string = 'mainnet'
-    ): Promise<number> {
-        const symbol = Midas.getSymbolFromContract(contractAddr);
-        
-        // Default to 30 days ago if not provided
-        const from = timestampFrom ?? Math.floor(Date.now() / 1000) - (30 * 24 * 60 * 60);
-        // Default to now if not provided
-        const to = timestampTo ?? Math.floor(Date.now() / 1000);
-        
-        try {
-            const response = await axios.get(`${Midas.BASE_URL}/${symbol}/price`, {
-                params: {
-                    timestampFrom: from,
-                    timestampTo: to,
-                    environment
-                }
-            });
-            
-            const priceData = response.data;
-            if (!Array.isArray(priceData) || priceData.length === 0) {
-                throw new Error(`No price data found for ${symbol}`);
-            }
-            
-            // Return the latest price (first item in the array)
-            return priceData[0].price;
-        } catch (error) {
-            logger.error(`Failed to fetch price for ${symbol}:`, error);
-            throw new Error(`Failed to fetch price for ${symbol}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-
-    /**
-     * Get TVL data for all tokens
-     * @param environment Environment (defaults to 'mainnet')
-     * @returns Object with TVL data including totalTvl and tokenTvl
-     * @throws Error if API request fails
-     */
-    static async getTVLData(environment: string = 'mainnet'): Promise<{
-        lastUpdatedAt: string;
-        totalTvl: number;
-        tokenTvl: Record<string, any>;
-    }> {
-        try {
-            const response = await axios.get(`${Midas.BASE_URL}/tvl`, {
-                params: { environment }
-            });
-            return response.data;
-        } catch (error) {
-            logger.error('Failed to fetch TVL data from Midas API:', error);
-            throw new Error(`Failed to fetch TVL data: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-
-    /**
-     * Get TVL for a specific token by contract address
-     * @param contractAddr The contract address of the token
-     * @param environment Environment (defaults to 'mainnet')
-     * @returns The TVL data for the token (USD and native amounts)
-     * @throws Error if contract address not found or API request fails
-     */
-    static async getTVL(
-        contractAddr: ContractAddr,
-        environment: string = 'mainnet'
-    ): Promise<{ usd: number; native: number } | number> {
-        const symbol = Midas.getSymbolFromContract(contractAddr);
-        const tvlData = await Midas.getTVLData(environment);
-        
-        if (!(symbol in tvlData.tokenTvl)) {
-            throw new Error(`Symbol ${symbol} not found in TVL data`);
-        }
-        
-        return tvlData.tokenTvl[symbol];
-    }
-}