@strkfarm/sdk 2.0.0-dev.2 → 2.0.0-dev.21

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

@@ -1,8 +1,14 @@
-import { BaseAdapter, DepositParams, WithdrawParams, BaseAdapterConfig } from "./baseAdapter";
+import {
+  BaseAdapter,
+  DepositParams,
+  WithdrawParams,
+  BaseAdapterConfig,
+} from "./baseAdapter";
 import { Protocols } from "@/interfaces";
 import { SupportedPosition } from "./baseAdapter";
 import { PositionAPY, APYType, PositionAmount } from "./baseAdapter";
 import { Web3Number } from "@/dataTypes";
+import { ApiResponse } from "@/modules/ExtendedWrapperSDk";
 import { PositionInfo } from "./baseAdapter";
 import { ManageCall } from "./baseAdapter";
 import { ContractAddr } from "@/dataTypes";
@@ -11,7 +17,12 @@ import { StandardMerkleTree } from "@/utils";
 import { hash, uint256 } from "starknet";
 import { Global } from "@/global";
 import { AdapterLeafType, GenerateCallFn } from "./baseAdapter";
-import { AVNU_LEGACY_SANITIZER, EXTENDED_SANITIZER, SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
+import {
+  AVNU_LEGACY_SANITIZER,
+  EXTENDED_SANITIZER,
+  SIMPLE_SANITIZER,
+  toBigInt,
+} from "./adapter-utils";
 import ExtendedWrapper, {
   AssetOperationStatus,
   AssetOperationType,
@@ -24,17 +35,21 @@ import { Balance, OpenOrder, OrderStatus } from "@/modules/ExtendedWrapperSDk";
 import axios from "axios";
 import { AvnuAdapter } from "./avnu-adapter";
 import { logger } from "@/utils";
+
+
 export interface ExtendedAdapterConfig extends BaseAdapterConfig {
   vaultIdExtended: number;
   extendedContract: ContractAddr; //0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f
-  extendedBackendUrl: string;
-  extendedApiKey: string;
+  extendedBackendReadUrl: string;
+  extendedBackendWriteUrl: string;
   extendedTimeout: number;
   extendedRetries: number;
   extendedBaseUrl: string;
   extendedMarketName: string;
   extendedPrecision: number;
   avnuAdapter: AvnuAdapter;
+  retryDelayForOrderStatus: number;
+  minimumExtendedMovementAmount: number;
 }
 
 export class ExtendedAdapter extends BaseAdapter<
@@ -43,17 +58,23 @@ 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);
     this.config = config as ExtendedAdapterConfig;
     const client = new ExtendedWrapper({
-      baseUrl: this.config.extendedBackendUrl,
-      apiKey: this.config.extendedApiKey,
+      baseUrl: this.config.extendedBackendWriteUrl,
+      apiKey: "",
       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(
@@ -61,23 +82,40 @@ export class ExtendedAdapter extends BaseAdapter<
   ): Promise<PositionAPY> {
     /** Considering supportedPosiiton.isDebt as side parameter to get the funding rates */
     const side = supportedPosition.isDebt ? "LONG" : "SHORT";
-    const fundingRates = await this.client.getFundingRates(this.config.extendedMarketName, side);
-    if (fundingRates.status !== "OK") {
+    const fundingRates = await this.getFundingRates(side);
+    if (!fundingRates.success) {
       logger.error("error getting funding rates", fundingRates);
       return { apy: 0, type: APYType.BASE };
     }
-    const fundingRate:FundingRate = fundingRates.data[0];
+    const fundingRate: FundingRate = fundingRates.data[0];
     const apy = Number(fundingRate.f) * 365 * 24;
     return { apy: apy, type: APYType.BASE };
   }
 
+  public async getFundingRates(side: string, startTime?: number, endTime?: number): Promise<{ success: boolean, data: FundingRate[] }> {
+    try {
+      const response = await axios.get<ApiResponse<FundingRate[]>>(`${this.config.extendedBackendReadUrl}/fundingRates/${this.config.extendedMarketName}/${side}`, {
+        params: {
+          startTime: startTime ? startTime.toString() : undefined,
+          endTime: endTime ? endTime.toString() : undefined,
+        }
+      });
+      if (!response.data.success) {
+        logger.error("error getting funding rates", response.data);
+        return { success: false, data: [] };
+      }
+      logger.info("success getting funding rates", response.data.data);
+      return { success: true, data: response.data.data };
+    } catch (err) {
+      logger.error("error getting funding rates", err);
+      return { success: false, data: [] };
+    }
+  }
+
   protected async getPosition(
     supportedPosition: SupportedPosition
   ): Promise<PositionAmount> {
-    if (!this.client) {
-      throw new Error("Client not initialized");
-    }
-    const holdings = await this.getExtendedDepositAmount();
+    const holdings = await this.getExtendedDepositAmount()
     if (!holdings) {
       throw new Error("No position found");
     }
@@ -85,7 +123,7 @@ export class ExtendedAdapter extends BaseAdapter<
     const amount = holdings.equity;
     return Promise.resolve({
       amount: new Web3Number(amount, 0),
-      remarks: `${holdings.availableForWithdrawal} ${holdings.equity}`,
+      remarks: `Extended Equity`,
     });
   }
 
@@ -118,14 +156,14 @@ export class ExtendedAdapter extends BaseAdapter<
     sanitizer: ContractAddr;
     id: string;
   }[] {
-    const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
     return [
       {
         target: this.config.supportedPositions[0].asset.address,
         method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
-        ],
+        packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
         id: `extended_approve_${this.config.supportedPositions[0].asset.symbol}`,
         sanitizer: AVNU_LEGACY_SANITIZER,
       },
@@ -155,19 +193,27 @@ export class ExtendedAdapter extends BaseAdapter<
 
   getSwapFromLegacyLeaf(): AdapterLeafType<DepositParams> {
     const leafConfigs = this._getSwapFromLegacyLeaf();
-    const leaves = leafConfigs.map(config => {
+    const leaves = leafConfigs.map((config) => {
       const { target, method, packedArguments, sanitizer, id } = config;
-      const leaf = this.constructSimpleLeafData({
-        id: id,
-        target,
-        method,
-        packedArguments
-      }, sanitizer);
+      const leaf = this.constructSimpleLeafData(
+        {
+          id: id,
+          target,
+          method,
+          packedArguments,
+        },
+        sanitizer
+      );
       return leaf;
     });
-    return { leaves, callConstructor: this.getSwapFromLegacyCall.bind(this) as unknown as GenerateCallFn<DepositParams> };
+    return {
+      leaves,
+      callConstructor: this.getSwapFromLegacyCall.bind(
+        this
+      ) as unknown as GenerateCallFn<DepositParams>,
+    };
   }
-  
+
   protected _getSwapFromLegacyLeaf(): {
     target: ContractAddr;
     method: string;
@@ -175,14 +221,14 @@ export class ExtendedAdapter extends BaseAdapter<
     sanitizer: ContractAddr;
     id: string;
   }[] {
-    const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
     return [
       {
         target: usdceToken!.address,
         method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
-        ],
+        packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
         id: `extendedswaplegacyapprove_${usdceToken!.symbol}`,
         sanitizer: AVNU_LEGACY_SANITIZER,
       },
@@ -193,10 +239,9 @@ export class ExtendedAdapter extends BaseAdapter<
         id: `extended_swap_to_new_${usdceToken!.symbol}`,
         sanitizer: AVNU_LEGACY_SANITIZER,
       },
-    ]
+    ];
   }
 
-
   protected _getWithdrawLeaf(): {
     target: ContractAddr;
     method: string;
@@ -213,12 +258,14 @@ export class ExtendedAdapter extends BaseAdapter<
   async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
     try {
       const usdcToken = this.config.supportedPositions[0].asset;
-      const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
-      const salt = Math.floor(
-        Math.random() * 10 ** usdcToken.decimals
+      const usdceToken = Global.getDefaultTokens().find(
+        (token) => token.symbol === "USDCe"
       );
+      const salt = Math.floor(Math.random() * 10 ** usdcToken.decimals);
       // Give approval for more amount than the required amount
-      const amount = uint256.bnToUint256(params.amount.multipliedBy(10).toWei());
+      const amount = uint256.bnToUint256(
+        params.amount.multipliedBy(10).toWei()
+      );
       const quotes = await this.config.avnuAdapter.getQuotesAvnu(
         usdcToken.address.toString(),
         usdceToken!.address.toString(),
@@ -226,15 +273,17 @@ export class ExtendedAdapter extends BaseAdapter<
         this.config.avnuAdapter.config.vaultAllocator.address.toString(),
         usdceToken!.decimals,
         false
-      )
+      );
 
       if (!quotes) {
         logger.error("error getting quotes from avnu");
         return [];
       }
-      const getCalldata = await this.config.avnuAdapter.getSwapCallData(quotes!);
+      const getCalldata = await this.config.avnuAdapter.getSwapCallData(
+        quotes!
+      );
       const swapCallData = getCalldata[0];
-       //change extended sanitizer here
+      //change extended sanitizer here
       return [
         {
           sanitizer: AVNU_LEGACY_SANITIZER,
@@ -287,35 +336,44 @@ export class ExtendedAdapter extends BaseAdapter<
     }
   }
 
-  getProofsForFromLegacySwap<T>(tree: StandardMerkleTree): { proofs: string[][], callConstructor: GenerateCallFn<DepositParams> | GenerateCallFn<WithdrawParams> } {
+  getProofsForFromLegacySwap<T>(tree: StandardMerkleTree): {
+    proofs: string[][];
+    callConstructor:
+    | GenerateCallFn<DepositParams>
+    | GenerateCallFn<WithdrawParams>;
+  } {
     let proofGroups: string[][] = [];
 
-    const ids = this.getSwapFromLegacyLeaf().leaves.map(l => l.readableId) 
+    const ids = this.getSwapFromLegacyLeaf().leaves.map((l) => l.readableId);
     // console.log(`${this.name}::getProofs ids: ${ids}`);
     for (const [i, v] of tree.entries()) {
-   //   console.log(`${this.name}::getProofs v: ${v.readableId}`);
+      //   console.log(`${this.name}::getProofs v: ${v.readableId}`);
       if (ids.includes(v.readableId)) {
-     //console.log(`${this.name}::getProofs found id: ${v.readableId}`);
+        //console.log(`${this.name}::getProofs found id: ${v.readableId}`);
         proofGroups.push(tree.getProof(i));
       }
     }
     if (proofGroups.length != ids.length) {
-      throw new Error(`Not all proofs found for IDs: ${ids.join(', ')}`);
+      throw new Error(`Not all proofs found for IDs: ${ids.join(", ")}`);
     }
 
     // find leaf adapter
     return {
       proofs: proofGroups,
-      callConstructor: this.getSwapFromLegacyCall.bind(this)
-      };
-    }
+      callConstructor: this.getSwapFromLegacyCall.bind(this),
+    };
+  }
 
   async getSwapFromLegacyCall(params: DepositParams): Promise<ManageCall[]> {
     try {
       const usdcToken = this.config.supportedPositions[0].asset;
-      const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
+      const usdceToken = Global.getDefaultTokens().find(
+        (token) => token.symbol === "USDCe"
+      );
       // Give approval for more amount than the required amount
-      const amount = uint256.bnToUint256(params.amount.multipliedBy(10).toWei());
+      const amount = uint256.bnToUint256(
+        params.amount.multipliedBy(10).toWei()
+      );
       const quotes = await this.config.avnuAdapter.getQuotesAvnu(
         usdceToken!.address.toString(),
         usdcToken!.address.toString(),
@@ -323,15 +381,17 @@ export class ExtendedAdapter extends BaseAdapter<
         this.config.avnuAdapter.config.vaultAllocator.address.toString(),
         usdcToken!.decimals,
         false
-      )
+      );
 
       if (!quotes) {
         logger.error("error getting quotes from avnu");
         return [];
       }
-      const getCalldata = await this.config.avnuAdapter.getSwapCallData(quotes!);
+      const getCalldata = await this.config.avnuAdapter.getSwapCallData(
+        quotes!
+      );
       const swapCallData = getCalldata[0];
-       //change extended sanitizer here
+      //change extended sanitizer here
       return [
         {
           sanitizer: AVNU_LEGACY_SANITIZER,
@@ -352,7 +412,7 @@ export class ExtendedAdapter extends BaseAdapter<
             selector: hash.getSelectorFromName("swap_to_new"),
             calldata: swapCallData,
           },
-        }
+        },
       ];
     } catch (error) {
       logger.error(`Error creating Deposit Call: ${error}`);
@@ -372,20 +432,105 @@ export class ExtendedAdapter extends BaseAdapter<
     }
   }
 
-  async withdrawFromExtended(amount: Web3Number): Promise<boolean> {
+  async withdrawFromExtended(amount: Web3Number): Promise<{
+    status: boolean;
+    receivedTxnHash: boolean;
+  }> {
     try {
       if (!this.client) {
-        throw new Error("Client not initialized");
+        logger.error("Client not initialized");
+        return {
+          status: false,
+          receivedTxnHash: false,
+        }
+      }
+      if (amount.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
+        );
+        return {
+          status: false,
+          receivedTxnHash: false,
+        }
+      }
+      if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
+        logger.warn(
+          `Withdrawal amount ${amount.toNumber()} is below minimum Extended movement amount ${this.minimumExtendedMovementAmount}. Skipping withdrawal.`
+        );
+        return {
+          status: false,
+          receivedTxnHash: false,
+        }
+      }
+      const holdings = await this.getExtendedDepositAmount();
+      if (!holdings) {
+        logger.error(
+          "Cannot get holdings - unable to validate withdrawal amount"
+        );
+        return {
+          status: false,
+          receivedTxnHash: false,
+        }
       }
-      const withdrawalRequest = await this.client.withdrawUSDC(amount.toFixed(2));
+
+      const availableForWithdrawal = parseFloat(
+        holdings.availableForWithdrawal
+      );
+      if (
+        !Number.isFinite(availableForWithdrawal) ||
+        availableForWithdrawal < 0
+      ) {
+        logger.error(
+          `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
+        );
+        return {
+          status: false,
+          receivedTxnHash: false,
+        }
+      }
+
+      const withdrawalAmount = amount.toNumber();
+      if (withdrawalAmount > availableForWithdrawal) {
+        logger.error(
+          `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
+        );
+        return {
+          status: false,
+          receivedTxnHash: 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, AssetOperationType.WITHDRAWAL);
-        return withdrawalStatus;
+        const withdrawalStatus = await this.getDepositOrWithdrawalStatus(
+          withdrawalRequest.data,
+          AssetOperationType.WITHDRAWAL
+        );
+        return {
+          status: true,
+          receivedTxnHash: withdrawalStatus,
+        }
+      }
+      logger.error(
+        `Withdrawal request failed with status: ${withdrawalRequest.status}`
+      );
+      return {
+        status: false,
+        receivedTxnHash: false,
       }
-      return false;
     } catch (error) {
       logger.error(`Error creating Withdraw Call: ${error}`);
-      return false;
+      return {
+        status: false,
+        receivedTxnHash: false,
+      }
     }
   }
 
@@ -394,21 +539,42 @@ 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 {
+      const result = await axios.get<ApiResponse<Balance>>(`${this.config.extendedBackendReadUrl}/holdings`);
+      if (!result.data) {
+        logger.error("error getting holdings - API returned null/undefined");
+        return undefined;
+      }
+
+      if (!result.data.success) {
+        logger.error(
+          `error getting holdings - API returned status: ${result.status}`
+        );
+        return undefined;
+      }
+
+      const holdings = result.data.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> {
@@ -427,54 +593,62 @@ export class ExtendedAdapter extends BaseAdapter<
   }
 
   async getAllOpenPositions(): Promise<Position[] | null> {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return null;
-    }
-    const response = await this.client.getPositionsForMarket(
-      this.config.extendedMarketName
-    );
-    if (response.status === "OK") {
-      if (response.data.length === 0) {
-        return [];
-      } else {
-        return response.data;
+    try {
+      const response = await axios.get<ApiResponse<Position[]>>(`${this.config.extendedBackendReadUrl}/positions`);
+      if (response.data.success) {
+        if (response.data.data.length === 0) {
+          return [];
+        } else {
+          return response.data.data;
+        }
       }
+      return null;
+    } catch (err) {
+      logger.error("error getting all open positions", err);
+      return null;
     }
-    return null;
   }
 
   async getOrderHistory(marketName: string): Promise<OpenOrder[] | null> {
-    if (this.client === null) {
-      logger.error("error initializing client");
+    try {
+      const result = await axios.get<ApiResponse<OpenOrder[]>>(`${this.config.extendedBackendReadUrl}/marketOrders/${marketName}`);
+      if (!result.data.success) {
+        return null;
+      }
+      return result.data.data;
+    } catch (err) {
+      logger.error("error getting order history", err);
       return null;
     }
-    const result = await this.client.getOrderHistory(marketName);
-    return result.data;
   }
 
   async getOrderStatus(
     orderId: string,
     marketName: string
   ): Promise<OpenOrder | null> {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return null;
-    }
-    const orderhistory = await this.getOrderHistory(marketName);
+    try {
+      if (this.client === null) {
+        logger.error("error initializing client");
+        return null;
+      }
+      const orderhistory = await this.getOrderHistory(marketName);
 
-    if (!orderhistory || orderhistory.length === 0) {
-      logger.error(`error getting order: ${orderId}`);
-      return null;
-    }
-    const order = orderhistory
-      .slice(0, 3)
-      .find((order) => order.id.toString() === orderId);
-    if (!order) {
-      logger.error(`error getting order: ${order}`);
+      if (!orderhistory || orderhistory.length === 0) {
+        return null;
+      }
+      const order = orderhistory
+        .slice(0, 20)
+        .find((order) => order.id.toString() === orderId);
+
+      if (order) {
+        return order;
+      }
+
+      return null; // Order not found
+    } catch (error) {
+      logger.error(`error getting order status: ${error}`);
       return null;
     }
-    return order;
   }
 
   async fetchOrderBookBTCUSDC(): Promise<{
@@ -536,16 +710,59 @@ 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
@@ -557,14 +774,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, this.config.extendedMarketName);
-      if (!openOrder || openOrder.status !== OrderStatus.FILLED) {
+
+      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
+      );
+      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;
@@ -578,13 +847,18 @@ 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) {
-      logger.error(`createShortOrder failed on attempt ${attempt}: ${err.message}`);
+      logger.error(
+        `createShortOrder failed on attempt ${attempt}: ${err.message}`
+      );
 
       if (attempt < maxAttempts) {
         const backoff = 1200 * attempt;
@@ -614,13 +888,13 @@ export class ExtendedAdapter extends BaseAdapter<
       const result =
         side === OrderSide.SELL
           ? await client.createSellOrder(marketName, amount, price, {
-              postOnly: false,
-              timeInForce: TimeInForce.IOC,
-            })
+            postOnly: false,
+            timeInForce: TimeInForce.IOC,
+          })
           : await client.createBuyOrder(marketName, amount, price, {
-              postOnly: false,
-              timeInForce: TimeInForce.IOC,
-            });
+            postOnly: false,
+            timeInForce: TimeInForce.IOC,
+          });
       if (result.data.id) {
         const position_id = result.data.id.toString();
         return {
@@ -634,28 +908,108 @@ export class ExtendedAdapter extends BaseAdapter<
     }
   }
 
-  async getDepositOrWithdrawalStatus(orderId: number | string, operationsType: AssetOperationType): Promise<boolean> {
-    try{
-      let transferHistory = await this.client.getAssetOperations({
-        operationsType:[operationsType],
-        operationsStatus:[AssetOperationStatus.COMPLETED]
-      })
-      if(operationsType === AssetOperationType.DEPOSIT){
-        const myTransferStatus = transferHistory.data.find(operation => operation.transactionHash === orderId);
-        if (!myTransferStatus) {
-          return true;
+  async getDepositOrWithdrawalStatus(
+    orderId: number | string, // for deposits, send txn hash as string
+    operationsType: AssetOperationType
+  ): Promise<boolean> {
+    const maxAttempts = 15;
+    const retryDelayMs = 30000; // 60 seconds
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        let transferHistory = await this.client.getAssetOperations({
+          operationsType: [operationsType],
+          operationsStatus: [AssetOperationStatus.COMPLETED],
+        });
+        if (operationsType === AssetOperationType.DEPOSIT) {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.transactionHash?.toLowerCase() === orderId.toString().toLowerCase()
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation not found for transactionHash ${orderId}, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation not found for transactionHash ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          // Check if status is COMPLETED
+          if (myTransferStatus.status === AssetOperationStatus.COMPLETED) {
+            logger.info(
+              `Deposit operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Deposit operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Deposit operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
+        } else {
+          const myTransferStatus = transferHistory.data.find(
+            (operation) => operation.id === orderId.toString()
+          );
+          if (!myTransferStatus) {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal status not found for orderId ${orderId} in completed operations, retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation not found for orderId ${orderId} after ${maxAttempts} attempts`
+            );
+            return false;
+          }
+          // Check if status is COMPLETED
+          if (myTransferStatus.status === AssetOperationStatus.COMPLETED) {
+            logger.info(
+              `Withdrawal operation ${orderId} completed successfully`
+            );
+            return true;
+          } else {
+            if (attempt < maxAttempts) {
+              logger.info(
+                `Withdrawal operation ${orderId} found but status is ${myTransferStatus.status}, not COMPLETED. Retrying (attempt ${attempt}/${maxAttempts})...`
+              );
+              await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+              continue;
+            }
+            logger.warn(
+              `Withdrawal operation ${orderId} status is ${myTransferStatus.status} after ${maxAttempts} attempts, expected COMPLETED`
+            );
+            return false;
+          }
         }
-        return true;
-      }else{
-        const myTransferStatus = transferHistory.data.find(operation => operation.id.toString() === orderId.toString());
-        if (!myTransferStatus) {
-          return true;
+      } catch (err) {
+        logger.error(
+          `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err}`
+        );
+        if (attempt < maxAttempts) {
+          logger.info(`Retrying after ${retryDelayMs}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+          continue;
         }
-        return true;
+        logger.error(
+          `Max retry attempts reached for getDepositOrWithdrawalStatus`
+        );
+        return false;
       }
-    }catch(err){
-      logger.error(`error getting deposit or withdrawal status: ${err}`);
-      return false;
     }
+
+    return false;
   }
 }