@strkfarm/sdk 2.0.0-dev.6 → 2.0.0-dev.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "2.0.0-dev.6",
+  "version": "2.0.0-dev.8",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "types": "dist/index.d.ts",

package/src/strategies/universal-adapters/avnu-adapter.ts

@@ -4,7 +4,7 @@ import {
   WithdrawParams,
   BaseAdapterConfig,
 } from "./baseAdapter";
-import { SIMPLE_SANITIZER_V2, toBigInt } from "./adapter-utils";
+import { toBigInt } from "./adapter-utils";
 import { Protocols } from "@/interfaces";
 import { MAX_DELAY } from "../vesu-extended-strategy/utils/constants";
 import { SupportedPosition } from "./baseAdapter";
@@ -13,14 +13,13 @@ import { Web3Number } from "@/dataTypes";
 import { PositionInfo } from "./baseAdapter";
 import { ManageCall } from "./baseAdapter";
 import { ContractAddr } from "@/dataTypes";
-import { TokenInfo } from "@/interfaces";
 import { AVNU_EXCHANGE } from "./adapter-utils";
 import { MAX_RETRIES } from "../vesu-extended-strategy/utils/constants";
 import { Quote } from "@avnu/avnu-sdk";
 import { hash, uint256 } from "starknet";
 import { AvnuWrapper } from "@/modules/avnu";
 import axios from "axios";
-import { AVNU_MIDDLEWARE, SIMPLE_SANITIZER } from "./adapter-utils";
+import {SIMPLE_SANITIZER } from "./adapter-utils";
 import { returnFormattedAmount } from "../vesu-extended-strategy/utils/helper";
 import { logger } from "@/utils";
 export interface AvnuAdapterConfig extends BaseAdapterConfig {

package/src/strategies/universal-adapters/extended-adapter.ts

@@ -45,6 +45,8 @@ export interface ExtendedAdapterConfig extends BaseAdapterConfig {
   extendedMarketName: string;
   extendedPrecision: number;
   avnuAdapter: AvnuAdapter;
+  retryDelayForOrderStatus: number;
+  minimumExtendedMovementAmount: number;
 }
 
 export class ExtendedAdapter extends BaseAdapter<
@@ -53,6 +55,8 @@ export class ExtendedAdapter extends BaseAdapter<
 > {
   readonly config: ExtendedAdapterConfig;
   readonly client: ExtendedWrapper;
+  readonly retryDelayForOrderStatus: number;
+  readonly minimumExtendedMovementAmount: number;
 
   constructor(config: ExtendedAdapterConfig) {
     super(config, ExtendedAdapter.name, Protocols.EXTENDED);
@@ -63,7 +67,11 @@ export class ExtendedAdapter extends BaseAdapter<
       timeout: this.config.extendedTimeout,
       retries: this.config.extendedRetries,
     });
+    this.minimumExtendedMovementAmount =
+      this.config.minimumExtendedMovementAmount ?? 5; //5 usdc
     this.client = client;
+    this.retryDelayForOrderStatus =
+      this.config.retryDelayForOrderStatus ?? 3000;
   }
   //abstract means the method has no implementation in this class; instead, child classes must implement it.
   protected async getAPY(
@@ -410,11 +418,58 @@ export class ExtendedAdapter extends BaseAdapter<
   async withdrawFromExtended(amount: Web3Number): Promise<boolean> {
     try {
       if (!this.client) {
-        throw new Error("Client not initialized");
+        logger.error("Client not initialized");
+        return false;
+      }
+      if (amount.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
+        );
+        return false;
+      }
+      if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
+        logger.warn(
+          `Withdrawal amount ${amount.toNumber()} is below minimum Extended movement amount ${this.minimumExtendedMovementAmount}. Skipping withdrawal.`
+        );
+        return false;
+      }
+      const holdings = await this.getExtendedDepositAmount();
+      if (!holdings) {
+        logger.error(
+          "Cannot get holdings - unable to validate withdrawal amount"
+        );
+        return false;
+      }
+
+      const availableForWithdrawal = parseFloat(
+        holdings.availableForWithdrawal
+      );
+      if (
+        !Number.isFinite(availableForWithdrawal) ||
+        availableForWithdrawal < 0
+      ) {
+        logger.error(
+          `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
+        );
+        return false;
       }
+
+      const withdrawalAmount = amount.toNumber();
+      if (withdrawalAmount > availableForWithdrawal) {
+        logger.error(
+          `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
+        );
+        return false;
+      }
+
+      logger.info(
+        `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
+      );
+
       const withdrawalRequest = await this.client.withdrawUSDC(
         amount.toFixed(2)
       );
+
       if (withdrawalRequest.status === "OK") {
         const withdrawalStatus = await this.getDepositOrWithdrawalStatus(
           withdrawalRequest.data,
@@ -422,6 +477,10 @@ export class ExtendedAdapter extends BaseAdapter<
         );
         return withdrawalStatus;
       }
+
+      logger.error(
+        `Withdrawal request failed with status: ${withdrawalRequest.status}`
+      );
       return false;
     } catch (error) {
       logger.error(`Error creating Withdraw Call: ${error}`);
@@ -434,21 +493,47 @@ export class ExtendedAdapter extends BaseAdapter<
   }
 
   async getExtendedDepositAmount(): Promise<Balance | undefined> {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return undefined;
-    }
-    const result = await this.client.getHoldings();
-    if (!result) {
-      logger.error(`error getting holdings: ${result}`);
-      return undefined;
-    }
-    const holdings = result.data;
-    if (!holdings) {
-      logger.error(`error getting holdings: ${holdings}`);
+    try {
+      if (this.client === null) {
+        logger.error("error initializing client - client is null");
+        return undefined; // Error: client not initialized
+      }
+
+      const result = await this.client.getHoldings();
+      if (!result) {
+        logger.error("error getting holdings - API returned null/undefined");
+        return undefined;
+      }
+
+      if (result.status && result.status !== "OK") {
+        logger.error(
+          `error getting holdings - API returned status: ${result.status}`
+        );
+        return undefined;
+      }
+
+      const holdings = result.data;
+      if (!holdings) {
+        logger.warn(
+          "holdings data is null/undefined - treating as zero balance"
+        );
+        return {
+          collateral_name: "",
+          balance: "0",
+          equity: "0",
+          availableForTrade: "0",
+          availableForWithdrawal: "0",
+          unrealisedPnl: "0",
+          initialMargin: "0",
+          marginRatio: "0",
+          updatedTime: Date.now(),
+        };
+      }
+      return holdings;
+    } catch (error) {
+      logger.error(`error getting holdings - exception: ${error}`);
       return undefined;
     }
-    return holdings;
   }
 
   async setLeverage(leverage: string, marketName: string): Promise<boolean> {
@@ -497,50 +582,29 @@ export class ExtendedAdapter extends BaseAdapter<
     orderId: string,
     marketName: string
   ): Promise<OpenOrder | null> {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return null;
-    }
-    let orderhistory = await this.getOrderHistory(marketName);
-
-    if (!orderhistory || orderhistory.length === 0) {
-      logger.error(`error getting order history: ${orderId}`);
-    } else {
-      const order = orderhistory
-        .slice(0, 5)
-        .find((order) => order.id.toString() === orderId);
-      if (order) {
-        return order;
+    try {
+      if (this.client === null) {
+        logger.error("error initializing client");
+        return null;
       }
-    }
-
-    // Retry logic: 3 more attempts with 3 second delay each
-    for (let attempt = 1; attempt <= 3; attempt++) {
-      await new Promise((resolve) => setTimeout(resolve, 3000));
-      orderhistory = await this.getOrderHistory(marketName);
+      const orderhistory = await this.getOrderHistory(marketName);
 
       if (!orderhistory || orderhistory.length === 0) {
-        logger.error(
-          `error getting order history on retry ${attempt}: ${orderId}`
-        );
-        continue;
+        return null;
       }
-
       const order = orderhistory
-        .slice(0, 5)
+        .slice(0, 20)
         .find((order) => order.id.toString() === orderId);
 
       if (order) {
         return order;
       }
 
-      logger.error(
-        `order not found in top 5 entries on retry ${attempt}: ${orderId}`
-      );
+      return null; // Order not found
+    } catch (error) {
+      logger.error(`error getting order status: ${error}`);
+      return null;
     }
-
-    logger.error(`error getting order after all retries: ${orderId}`);
-    return null;
   }
 
   async fetchOrderBookBTCUSDC(): Promise<{
@@ -602,16 +666,60 @@ export class ExtendedAdapter extends BaseAdapter<
         logger.error("error depositing or setting leverage");
         return null;
       }
-      const positions = await this.getAllOpenPositions();
-      if (positions === null) {
+      const { ask, bid } = await this.fetchOrderBookBTCUSDC();
+      if (
+        !ask ||
+        !bid ||
+        ask.lessThanOrEqualTo(0) ||
+        bid.lessThanOrEqualTo(0)
+      ) {
+        logger.error(
+          `Invalid orderbook prices: ask=${ask?.toNumber()}, bid=${bid?.toNumber()}`
+        );
         return null;
       }
-      const { ask, bid } = await this.fetchOrderBookBTCUSDC();
+
       const spread = ask.minus(bid);
-      let price = ask.plus(bid).div(2);
-      side === OrderSide.SELL
-        ? (price = price.minus(spread.times(0.2 * attempt)))
-        : (price = price.plus(spread.times(0.2 * attempt)));
+      const midPrice = ask.plus(bid).div(2);
+      /**  Maximum deviation: 50% of spread (to prevent extremely unfavorable prices) */
+      const MAX_PRICE_DEVIATION_MULTIPLIER = 0.5;
+      const priceAdjustmentMultiplier = Math.min(
+        0.2 * attempt,
+        MAX_PRICE_DEVIATION_MULTIPLIER
+      );
+      const priceAdjustment = spread.times(priceAdjustmentMultiplier);
+
+      let price = midPrice;
+      if (side === OrderSide.SELL) {
+        price = midPrice.minus(priceAdjustment);
+      } else {
+        price = midPrice.plus(priceAdjustment);
+      }
+
+      /**  Validate price is still reasonable (within 50% of mid price) */
+      const maxDeviation = midPrice.times(0.5);
+      if (price.minus(midPrice).abs().greaterThan(maxDeviation)) {
+        logger.error(
+          `Price deviation too large on attempt ${attempt}: price=${price.toNumber()}, midPrice=${midPrice.toNumber()}, deviation=${price
+            .minus(midPrice)
+            .abs()
+            .toNumber()}`
+        );
+        if (attempt >= maxAttempts) {
+          return null;
+        }
+        price =
+          side === OrderSide.SELL
+            ? midPrice.minus(maxDeviation)
+            : midPrice.plus(maxDeviation);
+      }
+
+      logger.info(
+        `createOrder attempt ${attempt}/${maxAttempts}: side=${side}, midPrice=${midPrice.toNumber()}, adjustedPrice=${price.toNumber()}, adjustment=${
+          priceAdjustmentMultiplier * 100
+        }%`
+      );
+
       const amount_in_token = (btcAmount * parseInt(leverage)).toFixed(
         this.config.extendedPrecision
       ); // gives the amount of wbtc
@@ -623,17 +731,66 @@ export class ExtendedAdapter extends BaseAdapter<
         price.toFixed(0),
         side
       );
-      if (!result) {
+      if (!result || !result.position_id) {
+        logger.error("Failed to create order - no position_id returned");
         return null;
       }
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-      const openOrder = await this.getOrderStatus(
-        result.position_id,
+
+      const positionId = result.position_id;
+      logger.info(
+        `Order created with position_id: ${positionId}. Waiting for API to update...`
+      );
+
+      let openOrder = await this.getOrderStatus(
+        positionId,
         this.config.extendedMarketName
       );
-      if (!openOrder || openOrder.status !== OrderStatus.FILLED) {
+      const maxStatusRetries = 3;
+      const statusRetryDelay = 5000;
+
+      if (!openOrder) {
+        logger.warn(
+          `Order ${positionId} not found in API yet. Retrying status fetch (max ${maxStatusRetries} times)...`
+        );
+        for (
+          let statusRetry = 1;
+          statusRetry <= maxStatusRetries;
+          statusRetry++
+        ) {
+          await new Promise((resolve) => setTimeout(resolve, statusRetryDelay));
+          openOrder = await this.getOrderStatus(
+            positionId,
+            this.config.extendedMarketName
+          );
+          if (openOrder) {
+            logger.info(
+              `Order ${positionId} found after ${statusRetry} status retry(ies)`
+            );
+            break;
+          }
+          logger.warn(
+            `Order ${positionId} still not found after ${statusRetry}/${maxStatusRetries} status retries`
+          );
+        }
+      }
+
+      if (openOrder && openOrder.status === OrderStatus.FILLED) {
+        logger.info(
+          `Order ${positionId} successfully filled with quantity ${openOrder.qty}`
+        );
+        return {
+          position_id: positionId,
+          btc_exposure: openOrder.qty,
+        };
+      } else if (openOrder && openOrder.status !== OrderStatus.FILLED) {
+        // Order found but NOT FILLED - retry (recreate)
+        logger.warn(
+          `Order ${positionId} found but status is ${openOrder.status}, not FILLED. Retrying order creation...`
+        );
         if (attempt >= maxAttempts) {
-          logger.error("Max retries reached — could not verify open position");
+          logger.error(
+            `Max retries reached — order ${positionId} status is ${openOrder.status}, not FILLED`
+          );
           return null;
         } else {
           const backoff = 2000 * attempt;
@@ -647,9 +804,12 @@ export class ExtendedAdapter extends BaseAdapter<
           );
         }
       } else {
+       logger.warn(
+          `Order ${positionId} not found in API after ${maxStatusRetries} status retries (API update delayed ~30s). We got position_id from creation, so order exists. Returning position_id - status will be checked in next loop iteration.`
+        );
         return {
-          position_id: result.position_id,
-          btc_exposure: openOrder.qty,
+          position_id: positionId,
+          btc_exposure: amount_in_token,
         };
       }
     } catch (err: any) {

package/src/strategies/universal-adapters/vesu-multiply-adapter.ts

@@ -50,6 +50,7 @@ export interface VesuMultiplyAdapterConfig extends BaseAdapterConfig {
   targetHealthFactor: number;
   minHealthFactor: number;
   quoteAmountToFetchPrice: Web3Number;
+  minimumVesuMovementAmount: number;
 }
 
 export class VesuMultiplyAdapter extends BaseAdapter<
@@ -59,7 +60,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
   readonly config: VesuMultiplyAdapterConfig;
   readonly vesuAdapter: VesuAdapter;
   readonly tokenMarketData: TokenMarketData;
-
+  readonly minimumVesuMovementAmount: number;
   constructor(config: VesuMultiplyAdapterConfig) {
     super(config, VesuMultiplyAdapter.name, Protocols.VESU);
     this.config = config;
@@ -70,6 +71,7 @@ export class VesuMultiplyAdapter extends BaseAdapter<
       vaultAllocator: config.vaultAllocator,
       id: "",
     });
+    this.minimumVesuMovementAmount = config.minimumVesuMovementAmount ?? 5; //5 usdc
     this.tokenMarketData = new TokenMarketData(
       this.config.pricer,
       this.config.networkConfig

package/src/strategies/universal-lst-muliplier-strategy.tsx

@@ -786,7 +786,8 @@ function getLooperSettings(
     minHealthFactor: vaultSettings.minHealthFactor,
     quoteAmountToFetchPrice: vaultSettings.quoteAmountToFetchPrice,
     ...baseAdapterConfig,
-    supportedPositions: [{asset: lstToken, isDebt: false}, {asset: Global.getDefaultTokens().find(token => token.symbol === position)!, isDebt: true}]
+    supportedPositions: [{asset: lstToken, isDebt: false}, {asset: Global.getDefaultTokens().find(token => token.symbol === position)!, isDebt: true}],
+    minimumVesuMovementAmount: 0 
   }));
 
   const unusedBalanceAdapter = new UnusedBalanceAdapter({

package/src/strategies/vesu-extended-strategy/utils/constants.ts

@@ -22,7 +22,7 @@ export const STRK_API_RPC = process.env.STRK_API_RPC ?? "https://mainnet.starkne
 export const MAX_RETRIES = Number(process.env.MAX_RETRIES ?? 3);
 export const MAX_DELAY = Number(process.env.MAX_DELAY ?? 100);
 export const EXTEND_MARKET_NAME = "BTC-USD";
-export const LIMIT_BALANCE = Number(process.env.LIMIT_BALANCE ?? 10);
+export const LIMIT_BALANCE = Number(process.env.LIMIT_BALANCE ?? 0.05);
 export const REBALANCER_INTERVAL = Number(process.env.REBALANCER_INTERVAL ?? 180000); //3 mins
 export const WITHDRAWAL_INTERVAL = Number(process.env.WITHDRAWAL_INTERVAL ?? 18000000); //5 hours
 export const INVESTING_INTERVAL = Number(process.env.INVESTING_INTERVAL ?? 180000); //3 mins