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

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

@@ -0,0 +1,976 @@
+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 { Global } from "@/global";
+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";
+export interface ExtendedAdapterConfig extends BaseAdapterConfig {
+  vaultIdExtended: number;
+  extendedContract: ContractAddr; //0x04270219d365d6b017231b52e92b3fb5d7c8378b05e9abc97724537a80e93b0f
+  extendedBackendUrl: string;
+  extendedApiKey: 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 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,
+      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(
+    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.client.getFundingRates(
+      this.config.extendedMarketName,
+      side
+    );
+    if (fundingRates.status !== "OK") {
+      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 };
+  }
+
+  protected async getPosition(
+    supportedPosition: SupportedPosition
+  ): Promise<PositionAmount> {
+    if (!this.client) {
+      throw new Error("Client not initialized");
+    }
+    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: `extendedAmount ${holdings.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;
+  }[] {
+    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()],
+        id: `extended_approve_${this.config.supportedPositions[0].asset.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+      {
+        target: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+        method: "swap_to_legacy",
+        packedArguments: [],
+        id: `extended_swap_to_legacy_${this.config.supportedPositions[0].asset.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+      {
+        target: usdceToken!.address,
+        method: "approve",
+        packedArguments: [this.config.extendedContract.toBigInt()],
+        id: `extended_approve_${usdceToken!.symbol}`,
+        sanitizer: SIMPLE_SANITIZER,
+      },
+      {
+        target: this.config.extendedContract,
+        method: "deposit",
+        packedArguments: [BigInt(this.config.vaultIdExtended)],
+        sanitizer: EXTENDED_SANITIZER,
+        id: `extended_deposit_${usdceToken!.symbol}`,
+      },
+    ];
+  }
+
+  getSwapFromLegacyLeaf(): AdapterLeafType<DepositParams> {
+    const leafConfigs = this._getSwapFromLegacyLeaf();
+    const leaves = leafConfigs.map((config) => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      const leaf = this.constructSimpleLeafData(
+        {
+          id: id,
+          target,
+          method,
+          packedArguments,
+        },
+        sanitizer
+      );
+      return leaf;
+    });
+    return {
+      leaves,
+      callConstructor: this.getSwapFromLegacyCall.bind(
+        this
+      ) as unknown as GenerateCallFn<DepositParams>,
+    };
+  }
+
+  protected _getSwapFromLegacyLeaf(): {
+    target: ContractAddr;
+    method: string;
+    packedArguments: bigint[];
+    sanitizer: ContractAddr;
+    id: string;
+  }[] {
+    const usdceToken = Global.getDefaultTokens().find(
+      (token) => token.symbol === "USDCe"
+    );
+    return [
+      {
+        target: usdceToken!.address,
+        method: "approve",
+        packedArguments: [AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt()],
+        id: `extendedswaplegacyapprove_${usdceToken!.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+      {
+        target: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+        method: "swap_to_new",
+        packedArguments: [],
+        id: `extended_swap_to_new_${usdceToken!.symbol}`,
+        sanitizer: AVNU_LEGACY_SANITIZER,
+      },
+    ];
+  }
+
+  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 usdcToken = this.config.supportedPositions[0].asset;
+      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).multipliedBy(10 ** usdceToken!.decimals).toFixed(0)
+      );
+
+
+      console.log(params, params.amount.multipliedBy(10).multipliedBy(10 ** usdceToken!.decimals).toFixed(0))
+      const quotes = await this.config.avnuAdapter.getQuotesAvnu(
+        usdcToken.address.toString(),
+        usdceToken!.address.toString(),
+        params.amount.toNumber(),
+        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 swapCallData = getCalldata[0];
+      //change extended sanitizer here
+      return [
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: usdcToken.address,
+            selector: hash.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+              toBigInt(amount.low.toString()), // amount low
+              toBigInt(amount.high.toString()), // amount high
+            ],
+          },
+        },
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+            selector: hash.getSelectorFromName("swap_to_legacy"),
+            calldata: swapCallData,
+          },
+        },
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: usdceToken!.address,
+            selector: hash.getSelectorFromName("approve"),
+            calldata: [
+              this.config.extendedContract.toBigInt(),
+              toBigInt(amount.low.toString()), // amount low
+              toBigInt(amount.high.toString()), // amount high
+            ],
+          },
+        },
+        {
+          sanitizer: EXTENDED_SANITIZER,
+          call: {
+            contractAddress: this.config.extendedContract,
+            selector: hash.getSelectorFromName("deposit"),
+            calldata: [
+              BigInt(this.config.vaultIdExtended),
+              BigInt(params.amount.multipliedBy(10 ** usdceToken!.decimals).toFixed(0)),
+              BigInt(salt),
+            ],
+          },
+        },
+      ];
+    } catch (error) {
+      logger.error(`Error creating Deposit Call: ${error}`);
+      return [];
+    }
+  }
+
+  getProofsForFromLegacySwap<T>(tree: StandardMerkleTree): {
+    proofs: string[][];
+    callConstructor:
+      | GenerateCallFn<DepositParams>
+      | GenerateCallFn<WithdrawParams>;
+  } {
+    let proofGroups: string[][] = [];
+
+    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}`);
+      if (ids.includes(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(", ")}`);
+    }
+
+    // find leaf adapter
+    return {
+      proofs: proofGroups,
+      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"
+      );
+      // Give approval for more amount than the required amount
+      const amount = uint256.bnToUint256(
+        params.amount.multipliedBy(10).toWei()
+      );
+      const quotes = await this.config.avnuAdapter.getQuotesAvnu(
+        usdceToken!.address.toString(),
+        usdcToken!.address.toString(),
+        params.amount.toNumber(),
+        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 swapCallData = getCalldata[0];
+      //change extended sanitizer here
+      return [
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: usdceToken!.address,
+            selector: hash.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE_FOR_LEGACY_USDC.toBigInt(),
+              toBigInt(amount.low.toString()), // amount low
+              toBigInt(amount.high.toString()), // amount high
+            ],
+          },
+        },
+        {
+          sanitizer: AVNU_LEGACY_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE_FOR_LEGACY_USDC,
+            selector: hash.getSelectorFromName("swap_to_new"),
+            calldata: swapCallData,
+          },
+        },
+      ];
+    } catch (error) {
+      logger.error(`Error creating Deposit Call: ${error}`);
+      return [];
+    }
+  }
+  //Swap wbtc to usdc
+  async getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]> {
+    try {
+      if (!this.client) {
+        throw new Error("Client not initialized");
+      }
+      return [];
+    } catch (error) {
+      logger.error(`Error creating Withdraw Call: ${error}`);
+      return [];
+    }
+  }
+
+  async withdrawFromExtended(amount: Web3Number): Promise<boolean> {
+    try {
+      if (!this.client) {
+        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,
+          AssetOperationType.WITHDRAWAL
+        );
+        return withdrawalStatus;
+      }
+
+      logger.error(
+        `Withdrawal request failed with status: ${withdrawalRequest.status}`
+      );
+      return false;
+    } catch (error) {
+      logger.error(`Error creating Withdraw Call: ${error}`);
+      return false;
+    }
+  }
+
+  async getHealthFactor(): Promise<number> {
+    return Promise.resolve(1);
+  }
+
+  async getExtendedDepositAmount(): Promise<Balance | undefined> {
+    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;
+    }
+  }
+
+  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> {
+    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;
+      }
+    }
+    return null;
+  }
+
+  async getOrderHistory(marketName: string): Promise<OpenOrder[] | null> {
+    if (this.client === null) {
+      logger.error("error initializing client");
+      return null;
+    }
+    const result = await this.client.getOrderHistory(marketName);
+    return result.data;
+  }
+
+  async getOrderStatus(
+    orderId: string,
+    marketName: string
+  ): Promise<OpenOrder | null> {
+    try {
+      if (this.client === null) {
+        logger.error("error initializing client");
+        return null;
+      }
+      const orderhistory = await this.getOrderHistory(marketName);
+
+      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;
+    }
+  }
+
+  async fetchOrderBookBTCUSDC(): 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: false,
+        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(`the err is: ${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;
+      }
+      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.fetchOrderBookBTCUSDC();
+      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, {
+              postOnly: false,
+              timeInForce: TimeInForce.IOC,
+            })
+          : await client.createBuyOrder(marketName, amount, price, {
+              postOnly: false,
+              timeInForce: 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;
+  }
+}