@strkfarm/sdk 2.0.0-dev.34 → 2.0.0-dev.36

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

@@ -1,835 +0,0 @@
-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 { PositionInfo } from "./baseAdapter";
-import { ManageCall } from "./baseAdapter";
-import { ContractAddr } from "@/dataTypes";
-import { AVNU_EXCHANGE_FOR_LEGACY_USDC } from "./adapter-utils";
-import { StandardMerkleTree } from "@/utils";
-import { hash, uint256 } from "starknet";
-import { AdapterLeafType, GenerateCallFn } from "./baseAdapter";
-import {
-  AVNU_LEGACY_SANITIZER,
-  EXTENDED_SANITIZER,
-  SIMPLE_SANITIZER,
-  toBigInt,
-} from "./adapter-utils";
-import ExtendedWrapper, {
-  AssetOperationStatus,
-  AssetOperationType,
-  FundingRate,
-  OrderSide,
-  Position,
-  TimeInForce,
-} from "@/modules/ExtendedWrapperSDk";
-import { Balance, OpenOrder, OrderStatus } from "@/modules/ExtendedWrapperSDk";
-import axios from "axios";
-import { AvnuAdapter } from "./avnu-adapter";
-import { logger } from "@/utils";
-import { TokenInfo } from "@/interfaces";
-
-export interface ExtendedAdapterConfig extends BaseAdapterConfig {
-  vaultIdExtended: number;
-  extendedContract: ContractAddr; //0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f
-  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<
-  DepositParams,
-  WithdrawParams
-> {
-  readonly config: ExtendedAdapterConfig;
-  readonly client: ExtendedWrapper;
-  readonly usdcToken: TokenInfo;
-  readonly retryDelayForOrderStatus: number;
-  readonly minimumExtendedMovementAmount: number;
-
-  constructor(config: ExtendedAdapterConfig) {
-    super(config, ExtendedAdapter.name, Protocols.EXTENDED);
-    this.config = config as ExtendedAdapterConfig;
-    const client = new ExtendedWrapper({
-      writeUrl: this.config.extendedBackendWriteUrl,
-      readUrl: this.config.extendedBackendReadUrl,
-      apiKey: "", // todo add auth
-      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;
-    this.usdcToken = this.config.supportedPositions[0].asset;
-  }
-
-  private _depositApproveProofReadableId(): string {
-    return `extended_approve_${this.usdcToken.symbol}`;
-  }
-
-  private _depositCallProofReadableId(): string {
-    return `extended_deposit_${this.usdcToken.symbol}`;
-  }
-  //abstract means the method has no implementation in this class; instead, child classes must implement it.
-  protected async getAPY(
-    supportedPosition: SupportedPosition,
-  ): Promise<PositionAPY> {
-    /** Considering supportedPosiiton.isDebt as side parameter to get the funding rates */
-    const side = supportedPosition.isDebt ? "LONG" : "SHORT";
-    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 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 this.client.getFundingRates(
-        this.config.extendedMarketName,
-        side,
-        startTime,
-        endTime,
-      );
-      if (response.status !== "OK") {
-        logger.error("error getting funding rates", response.data);
-        return { success: false, data: [] };
-      }
-      logger.debug(
-        `success getting funding rates market=${this.config.extendedMarketName} side=${side} count=${response.data.length}`,
-      );
-      return { success: true, data: response.data };
-    } catch (err) {
-      logger.error("error getting funding rates", err);
-      return { success: false, data: [] };
-    }
-  }
-
-  protected async getPosition(
-    supportedPosition: SupportedPosition,
-  ): Promise<PositionAmount> {
-    const holdings = await this.getExtendedDepositAmount();
-    if (!holdings) {
-      throw new Error("No position found");
-    }
-    // equity is the total amount on extended
-    const amount = holdings.equity;
-    return Promise.resolve({
-      amount: new Web3Number(amount, 0),
-      remarks: `Extended Equity`,
-    });
-  }
-
-  async maxDeposit(amount?: Web3Number): Promise<PositionInfo> {
-    return Promise.resolve({
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, 0),
-      usdValue: 0,
-      apy: { apy: 0, type: APYType.BASE },
-      protocol: Protocols.EXTENDED,
-      remarks: "",
-    });
-  }
-
-  async maxWithdraw(): Promise<PositionInfo> {
-    return Promise.resolve({
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, 0),
-      usdValue: 0,
-      apy: { apy: 0, type: APYType.BASE },
-      protocol: Protocols.EXTENDED,
-      remarks: "",
-    });
-  }
-
-  protected _getDepositLeaf(): {
-    target: ContractAddr;
-    method: string;
-    packedArguments: bigint[];
-    sanitizer: ContractAddr;
-    id: string;
-  }[] {
-    return [
-      {
-        target: this.usdcToken.address,
-        method: "approve",
-        packedArguments: [this.config.extendedContract.toBigInt()],
-        id: this._depositApproveProofReadableId(),
-        sanitizer: SIMPLE_SANITIZER,
-      },
-      {
-        target: this.config.extendedContract,
-        method: "deposit",
-        packedArguments: [BigInt(this.config.vaultIdExtended)],
-        sanitizer: EXTENDED_SANITIZER,
-        id: this._depositCallProofReadableId(),
-      },
-    ];
-  }
-
-  protected _getWithdrawLeaf(): {
-    target: ContractAddr;
-    method: string;
-    packedArguments: bigint[];
-    sanitizer: ContractAddr;
-    id: string;
-  }[] {
-    /**
-     * Withdraw is done via extended wrapper
-     */
-    return [];
-  }
-
-  async getDepositCall(params: DepositParams): Promise<ManageCall[]> {
-    try {
-      const salt = Math.floor(Math.random() * 10 ** this.usdcToken.decimals);
-      const amount = uint256.bnToUint256(params.amount.toWei());
-      return [
-        {
-          proofReadableId: this._depositApproveProofReadableId(),
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: this.usdcToken.address,
-            selector: hash.getSelectorFromName("approve"),
-            calldata: [
-              this.config.extendedContract.toBigInt(),
-              toBigInt(amount.low.toString()), // amount low
-              toBigInt(amount.high.toString()), // amount high
-            ],
-          },
-        },
-        {
-          proofReadableId: this._depositCallProofReadableId(),
-          sanitizer: EXTENDED_SANITIZER,
-          call: {
-            contractAddress: this.config.extendedContract,
-            selector: hash.getSelectorFromName("deposit"),
-            calldata: [
-              BigInt(this.config.vaultIdExtended),
-              BigInt(params.amount.toWei()),
-              BigInt(salt),
-            ],
-          },
-        },
-      ];
-    } catch (error) {
-      logger.error(`Error creating Deposit Call: ${error}`);
-      return [];
-    }
-  }
-
-  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
-    try {
-      return [];
-    } catch (error) {
-      logger.error(`Error creating Withdraw Call: ${error}`);
-      return [];
-    }
-  }
-
-  async withdrawFromExtended(amount: Web3Number): Promise<{
-    status: boolean;
-    receivedTxnHash: boolean;
-  }> {
-    try {
-      if (!this.client) {
-        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 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 {
-          status: true,
-          receivedTxnHash: withdrawalStatus,
-        };
-      }
-      logger.error(
-        `Withdrawal request failed with status: ${withdrawalRequest.status}`,
-      );
-      return {
-        status: false,
-        receivedTxnHash: false,
-      };
-    } catch (error) {
-      logger.error(`Error creating Withdraw Call: ${error}`);
-      return {
-        status: false,
-        receivedTxnHash: false,
-      };
-    }
-  }
-
-  async getHealthFactor(): Promise<number> {
-    return Promise.resolve(1);
-  }
-
-  async getExtendedDepositAmount(): Promise<Balance | undefined> {
-    const failResult = {
-      collateral_name: "",
-      balance: "0",
-      equity: "0",
-      availableForTrade: "0",
-      availableForWithdrawal: "0",
-      unrealisedPnl: "0",
-      initialMargin: "0",
-      marginRatio: "0",
-      updatedTime: Date.now(),
-    };
-    const fail = (message: string) => {
-      logger.error(message);
-      return failResult;
-    };
-
-    try {
-      const result = await this.client.getHoldings();
-      if (result.status !== "OK") {
-        return fail("error getting holdings - API returned null/undefined");
-      }
-      const holdings = result.data;
-      if (!holdings) {
-        return fail(
-          "holdings data is null/undefined - treating as zero balance",
-        );
-      }
-      return holdings;
-    } catch (error) {
-      return fail(`error getting holdings - exception: ${error}`);
-    }
-  }
-
-  async setLeverage(leverage: string, marketName: string): Promise<boolean> {
-    if (this.client === null) {
-      logger.error("error initializing client");
-      return false;
-    }
-    const res = await this.client.updateLeverage({
-      leverage: leverage,
-      market: marketName,
-    });
-    if (res.status === "OK") {
-      return true;
-    }
-    return false;
-  }
-
-  async getAllOpenPositions(): Promise<Position[] | null> {
-    try {
-      const response = await this.client.getPositions(
-        this.config.extendedMarketName,
-      );
-      if (response.status === "OK") {
-        if (response.data.length === 0) {
-          return [];
-        } else {
-          return response.data;
-        }
-      }
-      return null;
-    } catch (err) {
-      logger.error("error getting all open positions", err);
-      return null;
-    }
-  }
-
-  // async getOrderHistory(marketName: string): Promise<OpenOrder[] | null> {
-  //   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;
-  //   }
-  // }
-
-  async getOrderStatus(
-    orderId: string,
-    marketName: string,
-  ): Promise<OpenOrder | null> {
-    try {
-      if (this.client === null) {
-        logger.error("error initializing client");
-        return null;
-      }
-      const orderhistoryResponse =
-        await this.client.getOrderHistory(marketName);
-
-      if (
-        orderhistoryResponse.status !== "OK" ||
-        orderhistoryResponse.data.length === 0
-      ) {
-        return null;
-      }
-      const orderhistory = orderhistoryResponse.data;
-      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;
-    }
-  }
-
-  async fetchOrderBookFromExtended(): Promise<{
-    status: boolean;
-    bid: Web3Number;
-    ask: Web3Number;
-  }> {
-    try {
-      const res = await axios.get(
-        `${this.config.extendedBaseUrl}/api/v1/info/markets/${this.config.extendedMarketName}/orderbook`,
-      );
-      let ask_price = new Web3Number(0, 0);
-      let bid_price = new Web3Number(0, 0);
-      if (res.data.status !== "OK") {
-        return {
-          status: false,
-          bid: bid_price,
-          ask: ask_price,
-        };
-      }
-      const data = res.data.data;
-      const bid = data.bid[0];
-      const ask = data.ask[0];
-      ask_price = new Web3Number(ask.price, 0);
-      bid_price = new Web3Number(bid.price, 0);
-
-      return {
-        status: true,
-        bid: bid_price, // check for quantity as well, not at the moment though
-        ask: ask_price, // check for quantity as well, not at the moment though
-      };
-    } catch (err) {
-      logger.error(`extended orderbook fetch failed: ${err}`);
-      return {
-        status: false,
-        bid: new Web3Number(0, 0),
-        ask: new Web3Number(0, 0),
-      };
-    }
-  }
-
-  async createOrder(
-    leverage: string,
-    btcAmount: number,
-    side: OrderSide,
-    attempt = 1,
-    maxAttempts = 5,
-  ): Promise<{ position_id: string; btc_exposure: string } | null> {
-    try {
-      if (this.client === null) {
-        logger.error("error initializing client");
-        return null;
-      }
-      // todo, instead get levgerage and log errors if not ideal lever already
-      // const setLeverage = await this.setLeverage(
-      //   leverage,
-      //   this.config.extendedMarketName,
-      // );
-      // if (!setLeverage) {
-      //   logger.error("error depositing or setting leverage");
-      //   return null;
-      // }
-      const { ask, bid } = await this.fetchOrderBookFromExtended();
-      if (
-        !ask ||
-        !bid ||
-        ask.lessThanOrEqualTo(0) ||
-        bid.lessThanOrEqualTo(0)
-      ) {
-        logger.error(
-          `Invalid orderbook prices: ask=${ask?.toNumber()}, bid=${bid?.toNumber()}`,
-        );
-        return null;
-      }
-
-      const spread = ask.minus(bid);
-      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
-
-      const result = await this.createExtendedPositon(
-        this.client,
-        this.config.extendedMarketName,
-        amount_in_token,
-        price.toFixed(0),
-        side,
-      );
-      if (!result || !result.position_id) {
-        logger.error("Failed to create order - no position_id returned");
-        return null;
-      }
-
-      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 — order ${positionId} status is ${openOrder.status}, not FILLED`,
-          );
-          return null;
-        } else {
-          const backoff = 2000 * attempt;
-          await new Promise((resolve) => setTimeout(resolve, backoff));
-          return this.createOrder(
-            leverage,
-            btcAmount,
-            side,
-            attempt + 1,
-            maxAttempts,
-          );
-        }
-      } 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: positionId,
-          btc_exposure: amount_in_token,
-        };
-      }
-    } catch (err: any) {
-      logger.error(
-        `createShortOrder failed on attempt ${attempt}: ${err.message}`,
-      );
-
-      if (attempt < maxAttempts) {
-        const backoff = 1200 * attempt;
-        logger.info(`Retrying after ${backoff}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, backoff));
-        return this.createOrder(
-          leverage,
-          btcAmount,
-          side,
-          attempt + 1,
-          maxAttempts,
-        );
-      }
-      logger.error("Max retry attempts reached — aborting createShortOrder");
-      return null;
-    }
-  }
-
-  async createExtendedPositon(
-    client: ExtendedWrapper,
-    marketName: string,
-    amount: string,
-    price: string,
-    side: OrderSide,
-  ) {
-    try {
-      const result =
-        side === OrderSide.SELL
-          ? await client.createSellOrder(marketName, amount, price, {
-            post_only: false,
-            reduce_only: false,
-            time_in_force: TimeInForce.IOC,
-          })
-          : await client.createBuyOrder(marketName, amount, price, {
-            post_only: false,
-            reduce_only: true,
-            time_in_force: TimeInForce.IOC,
-          });
-      if (result.data.id) {
-        const position_id = result.data.id.toString();
-        return {
-          position_id,
-        };
-      }
-      return null;
-    } catch (err) {
-      logger.error(`Error opening short extended position, ${err}`);
-      return null;
-    }
-  }
-
-  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;
-          }
-        }
-      } 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;
-        }
-        logger.error(
-          `Max retry attempts reached for getDepositOrWithdrawalStatus`,
-        );
-        return false;
-      }
-    }
-
-    return false;
-  }
-}