@strkfarm/sdk 1.2.0 → 2.0.0-dev-strategy2.1

package/src/modules/ExtendedWrapperSDk/wrapper.ts

@@ -0,0 +1,448 @@
+/**
+ * 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 text = await response.text();
+
+        // Replace large integers (greater than MAX_SAFE_INTEGER) with quoted strings
+        // This regex finds numbers that are likely to be large integers in the "data" field
+        const MAX_SAFE_INTEGER_STR = "9007199254740991";
+        const largeIntegerRegex = /"data"\s*:\s*(\d{16,})/g;
+
+        const modifiedText = text.replace(
+          largeIntegerRegex,
+          (match, largeInt) => {
+            // Compare as strings to avoid precision loss
+            if (
+              largeInt.length > MAX_SAFE_INTEGER_STR.length ||
+              (largeInt.length === MAX_SAFE_INTEGER_STR.length &&
+                largeInt > MAX_SAFE_INTEGER_STR)
+            ) {
+              // Replace the number with a quoted string to preserve precision
+              return `"data":"${largeInt}"`;
+            }
+            return match; // Keep original if it's a safe integer
+          }
+        );
+
+        const data = JSON.parse(modifiedText);
+
+        if (data && typeof data.data === "string" && /^\d+$/.test(data.data)) {
+          const numValue = Number(data.data);
+          if (Number.isSafeInteger(numValue)) {
+            data.data = numValue;
+          }
+        }
+
+        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
+   * Returns data as number | string to preserve precision for large integers
+   */
+  async withdraw(
+    request: WithdrawRequest
+  ): Promise<ExtendedApiResponse<number | string>> {
+    return this.makeRequest<number | string>("/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;
+      page?: 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.page !== undefined)
+      params.append("page", options.page.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)
+   * Returns data as number | string to preserve precision for large integers
+   */
+  async withdrawUSDC(
+    amount: string
+  ): Promise<ExtendedApiResponse<number | string>> {
+    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
+   * @param side - The side (BUY/SELL)
+   * @param options - Optional parameters for filtering and pagination
+   * @param options.startTime - Start timestamp for filtering (ISO format datetime string)
+   * @param options.endTime - End timestamp for filtering (ISO format datetime string)
+   * @param options.page - Page number (default: 1, 10 entries per page)
+   * @returns The funding rates for the specified market
+   */
+  async getFundingRates(
+    marketName: string,
+    side: string,
+    options: {
+      startTime?: string;
+      endTime?: string;
+      page?: number;
+    } = {}
+  ): Promise<ExtendedApiResponse<FundingRate[]>> {
+    const params = new URLSearchParams();
+    params.append("market_name", marketName);
+    params.append("side", side);
+    if (options.startTime !== undefined)
+      params.append("start_time", options.startTime);
+    if (options.endTime !== undefined)
+      params.append("end_time", options.endTime);
+    if (options.page !== undefined)
+      params.append("page", options.page.toString());
+
+    const queryString = params.toString();
+    const endpoint = `/api/v1/markets/funding-rates?${queryString}`;
+
+    return this.makeRequest<FundingRate[]>(endpoint);
+  }
+}
+
+export default ExtendedWrapper;

package/src/modules/avnu.ts

@@ -37,7 +37,7 @@ export class AvnuWrapper {
     excludeSources = ['Haiko(Solvers)']
   ): Promise<Quote> {
     const MAX_RETRY = 5;
-    // logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
+    logger.verbose(`${AvnuWrapper.name}: getQuotes => Getting quotes for ${fromToken} -> ${toToken}, amount: ${amountWei}, taker: ${taker}, retry: ${retry}`);
     const params: any = {
       sellTokenAddress: fromToken,
       buyTokenAddress: toToken,
@@ -100,9 +100,9 @@ export class AvnuWrapper {
     // swapInfo as expected by the strategy
     // fallback, max 1% slippage
     const _minAmount = minAmount || (quote.buyAmount * 95n / 100n).toString();
-    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
-    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
-    // logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => sellToken: ${quote.sellTokenAddress}, sellAmount: ${quote.sellAmount}`);
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyToken: ${quote.buyTokenAddress}`);
+    logger.verbose(`${AvnuWrapper.name}: getSwapInfo => buyAmount: ${quote.buyAmount}, minAmount: ${_minAmount}`);
     const swapInfo: SwapInfo = {
       token_from_address: quote.sellTokenAddress,
       token_from_amount: uint256.bnToUint256(quote.sellAmount),
@@ -135,4 +135,17 @@ export class AvnuWrapper {
       routes: [],
     };
   }
+
+
+  async getSwapCallData(
+    quote: Pick<Quote, 'quoteId' | 'buyTokenAddress' | 'buyAmount' | 'sellTokenAddress' | 'sellAmount'>,
+    taker: string,
+  ) {
+    const calldata = await fetchBuildExecuteTransaction(quote.quoteId, taker, undefined, false);
+    const result = calldata.calls.map((call: Call) => {
+      const data = call.calldata as string[];
+      return data.map(x => BigInt(x));
+    });
+    return result;
+  }
 }

package/src/modules/ekubo-quoter.ts

@@ -2,6 +2,12 @@ import { ContractAddr, Web3Number } from "@/dataTypes";
 import { IConfig, TokenInfo } from "@/interfaces/common";
 import { Swap } from "@/strategies";
 import axios from "axios";
+import { logger } from "@/utils";
+import { uint256 } from "starknet";
+import { Contract } from "starknet";
+import ERC4626Abi from "@/data/erc4626.abi.json";
+import { TokenMarketData } from "./token-market-data";
+import { PricerBase } from "./pricerBase";
 
 export interface EkuboRouteNode {
   pool_key: {
@@ -29,8 +35,11 @@ export interface EkuboQuote {
 
 export class EkuboQuoter {
   ENDPOINT = 'https://prod-api-quoter.ekubo.org/23448594291968334/{{AMOUNT}}/{{TOKEN_FROM_ADDRESS}}/{{TOKEN_TO_ADDRESS}}'; // e.g. ETH/USDC'
-  
-  constructor(private readonly config: IConfig) {}
+  tokenMarketData: TokenMarketData;
+
+  constructor(private readonly config: IConfig, pricer: PricerBase) {
+    this.tokenMarketData = new TokenMarketData(pricer, config);
+  }
 
   /**
    * 
@@ -40,16 +49,17 @@ export class EkuboQuoter {
    * @returns 
    */
   async getQuote(fromToken: string, toToken: string, amount: Web3Number, retry = 0): Promise<EkuboQuote> {
-    let _fromToken = amount.gt(0) ? fromToken : toToken;
-    let _toToken = amount.gt(0) ? toToken : fromToken;
+    // let _fromToken = amount.gt(0) ? fromToken : toToken;
+    // let _toToken = amount.gt(0) ? toToken : fromToken;
 
     try {
-      const quote = await axios.get(this.ENDPOINT.replace("{{AMOUNT}}", amount.toWei()).replace("{{TOKEN_FROM_ADDRESS}}", _fromToken).replace("{{TOKEN_TO_ADDRESS}}", _toToken));
-      console.log(`Ekubo quote from ${_fromToken} to ${_toToken} for ${amount.toString()}: ${JSON.stringify(quote.data)}`);
-      return quote.data as EkuboQuote;
+      const url = this.ENDPOINT.replace("{{AMOUNT}}", amount.toFixed(0)).replace("{{TOKEN_FROM_ADDRESS}}", fromToken).replace("{{TOKEN_TO_ADDRESS}}", toToken);
+      console.log("url", url);
+      const quote = await axios.get(url);
+     return quote.data as EkuboQuote;
     } catch (error: any) {
-      console.error(error.message, 'dassf', error.data);
-      if (retry < 10) {
+      logger.error(`${error.message} dassf ${error.data}`);
+      if (retry < 3) {
         await new Promise((resolve) => setTimeout(resolve, (retry + 1) * 5000));
         return await this.getQuote(fromToken, toToken, amount, retry + 1);
       }
@@ -57,6 +67,72 @@ export class EkuboQuoter {
     }
   }
 
+  async getDexPrice(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number) {
+    const lstTokenInfo = baseToken;
+    const lstUnderlyingTokenInfo = quoteToken;
+    const quote = await this.getQuote(
+      lstTokenInfo.address.address,
+      lstUnderlyingTokenInfo.address.address,
+      amount
+    );
+    // in Underlying
+    const outputAmount = Web3Number.fromWei(quote.total_calculated, lstUnderlyingTokenInfo.decimals);
+    const price = outputAmount.toNumber() / amount.toNumber();
+    logger.verbose(`${EkuboQuoter.name}:: LST Dex Price: ${price}`);
+    return price;
+  }
+
+  async getLSTTrueExchangeRate(baseToken: TokenInfo, quoteToken: TokenInfo, amount: Web3Number) {
+    const lstTokenInfo = baseToken;
+    const lstABI = new Contract({
+      abi: ERC4626Abi,
+      address: lstTokenInfo.address.address,
+      providerOrAccount: this.config.provider
+    });
+
+    const price: any = await lstABI.call('convert_to_assets', [uint256.bnToUint256((new Web3Number(1, lstTokenInfo.decimals)).toWei())]);
+    const exchangeRate = Number(uint256.uint256ToBN(price).toString()) / Math.pow(10, lstTokenInfo.decimals);
+    logger.verbose(`${EkuboQuoter.name}:: LST true Exchange Rate: ${exchangeRate}`);
+    return exchangeRate;
+  }
+  // debt collateral 
+  async getSwapLimitAmount(fromToken: TokenInfo, toToken: TokenInfo, amount: Web3Number, max_slippage: number = 0.002): Promise<Web3Number> {
+    const isExactAmountIn = amount.greaterThanOrEqualTo(0);
+    logger.verbose(`${EkuboQuoter.name}::getSwapLimitAmount isExactAmountIn: ${isExactAmountIn}, fromToken: ${fromToken.symbol}, toToken: ${toToken.symbol}, amount: ${amount}`);
+    const isYieldToken = this.tokenMarketData.isAPYSupported(toToken);
+    console.log("isYieldToken", isYieldToken);
+    
+    // if LST, get true exchange rate else use dex price
+    // wbtc
+    const baseToken = isExactAmountIn ? toToken : fromToken; // fromToken -> wbtc, 
+    const quoteToken = isExactAmountIn ? fromToken : toToken; // toToken -> usdc, 
+    // need dex price of from token in toToken
+    // from baseToken to underlying token
+    // for withdraw, usdc to btc with amount negative
+    const dexPrice = await this.getDexPrice(baseToken, quoteToken, amount);
+    const trueExchangeRate = isYieldToken ? await this.tokenMarketData.getTruePrice(baseToken) : dexPrice;
+    console.log("trueExchangeRate", trueExchangeRate);
+    if (isExactAmountIn) {
+      let minLSTReceived = amount.dividedBy(dexPrice).multipliedBy(1 - max_slippage); // used for increase
+      console.log("minLSTReceived", minLSTReceived);
+      const minLSTReceivedAsPerTruePrice = amount.dividedBy(trueExchangeRate); // execution output to be <= True LST price
+      if (minLSTReceived < minLSTReceivedAsPerTruePrice) {
+        minLSTReceived = minLSTReceivedAsPerTruePrice; // the execution shouldn't be bad than True price logi
+      }
+      logger.verbose(`${EkuboQuoter.name}::getModifyLeverCall minLSTReceivedAsPerTruePrice: ${minLSTReceivedAsPerTruePrice}, minLSTReceived: ${minLSTReceived}`);
+      return minLSTReceived;
+    }
+    
+    let maxUsedCollateral = amount.abs().dividedBy(dexPrice).multipliedBy(1 + max_slippage); // +ve for exact amount out, used for decrease
+    const maxUsedCollateralInLST = amount.abs().dividedBy(trueExchangeRate).multipliedBy(1.005); // 0.5% slippage, worst case based on true price
+    logger.verbose(`${EkuboQuoter.name}::getModifyLeverCall maxUsedCollateralInLST: ${maxUsedCollateralInLST}, maxUsedCollateral: ${maxUsedCollateral}`);
+    if (maxUsedCollateralInLST > maxUsedCollateral) {
+      maxUsedCollateral = maxUsedCollateralInLST;
+    }
+    
+    return maxUsedCollateral;
+  }
+
   /**
    * Formats Ekubo response for Vesu multiple use
    * @param quote 
@@ -65,7 +141,7 @@ export class EkuboQuoter {
    */
   getVesuMultiplyQuote(quote: EkuboQuote, fromTokenInfo: TokenInfo, toTokenInfo: TokenInfo): Swap[] {
     return quote.splits.map(split => {
-      const isNegativeAmount = BigInt(split.amount_specified) < 0n;
+      const isNegativeAmount = BigInt(split.amount_specified) <= 0n;
       const token = isNegativeAmount ? toTokenInfo : fromTokenInfo;
       return {
         route: split.route.map(_route => ({
@@ -81,6 +157,9 @@ export class EkuboQuoter {
         })),
         token_amount: {
           token: token.address,
+          /**
+           * For closing position, put this as 0
+           */
           amount: Web3Number.fromWei(split.amount_specified, token.decimals)
         }
       };