@strkfarm/sdk 2.0.0-dev.27 → 2.0.0-dev.28

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

@@ -8,14 +8,12 @@ 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";
 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,
@@ -35,7 +33,7 @@ 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;
@@ -58,6 +56,7 @@ export class ExtendedAdapter extends BaseAdapter<
 > {
   readonly config: ExtendedAdapterConfig;
   readonly client: ExtendedWrapper;
+  readonly usdceToken: TokenInfo;
   readonly retryDelayForOrderStatus: number;
   readonly minimumExtendedMovementAmount: number;
 
@@ -65,8 +64,9 @@ export class ExtendedAdapter extends BaseAdapter<
     super(config, ExtendedAdapter.name, Protocols.EXTENDED);
     this.config = config as ExtendedAdapterConfig;
     const client = new ExtendedWrapper({
-      baseUrl: this.config.extendedBackendWriteUrl,
-      apiKey: "",
+      writeUrl: this.config.extendedBackendWriteUrl,
+      readUrl: this.config.extendedBackendReadUrl,
+      apiKey: "", // todo add auth
       timeout: this.config.extendedTimeout,
       retries: this.config.extendedRetries,
     });
@@ -75,10 +75,19 @@ export class ExtendedAdapter extends BaseAdapter<
     this.client = client;
     this.retryDelayForOrderStatus =
       this.config.retryDelayForOrderStatus ?? 3000;
+    this.usdceToken = this.config.supportedPositions[0].asset;
+  }
+
+  private _depositApproveProofReadableId(): string {
+    return `extended_approve_${this.usdceToken.symbol}`;
+  }
+
+  private _depositCallProofReadableId(): string {
+    return `extended_deposit_${this.usdceToken.symbol}`;
   }
   //abstract means the method has no implementation in this class; instead, child classes must implement it.
   protected async getAPY(
-    supportedPosition: SupportedPosition
+    supportedPosition: SupportedPosition,
   ): Promise<PositionAPY> {
     /** Considering supportedPosiiton.isDebt as side parameter to get the funding rates */
     const side = supportedPosition.isDebt ? "LONG" : "SHORT";
@@ -92,20 +101,26 @@ export class ExtendedAdapter extends BaseAdapter<
     return { apy: apy, type: APYType.BASE };
   }
 
-  public async getFundingRates(side: string, startTime?: number, endTime?: number): Promise<{ success: boolean, data: FundingRate[] }> {
+  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) {
+      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.info("success getting funding rates", response.data.data);
-      return { success: true, data: response.data.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: [] };
@@ -113,9 +128,9 @@ export class ExtendedAdapter extends BaseAdapter<
   }
 
   protected async getPosition(
-    supportedPosition: SupportedPosition
+    supportedPosition: SupportedPosition,
   ): Promise<PositionAmount> {
-    const holdings = await this.getExtendedDepositAmount()
+    const holdings = await this.getExtendedDepositAmount();
     if (!holdings) {
       throw new Error("No position found");
     }
@@ -156,29 +171,12 @@ export class ExtendedAdapter extends BaseAdapter<
     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,
+        target: this.usdceToken.address,
         method: "approve",
         packedArguments: [this.config.extendedContract.toBigInt()],
-        id: `extended_approve_${usdceToken!.symbol}`,
+        id: this._depositApproveProofReadableId(),
         sanitizer: SIMPLE_SANITIZER,
       },
       {
@@ -186,58 +184,7 @@ export class ExtendedAdapter extends BaseAdapter<
         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,
+        id: this._depositCallProofReadableId(),
       },
     ];
   }
@@ -257,58 +204,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);
-      // 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(
-        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
+      const salt = Math.floor(Math.random() * 10 ** this.usdceToken.decimals);
+      const amount = uint256.bnToUint256(params.amount.toWei());
       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,
-          },
-        },
-        {
+          proofReadableId: this._depositApproveProofReadableId(),
           sanitizer: SIMPLE_SANITIZER,
           call: {
-            contractAddress: usdceToken!.address,
+            contractAddress: this.usdceToken.address,
             selector: hash.getSelectorFromName("approve"),
             calldata: [
               this.config.extendedContract.toBigInt(),
@@ -318,6 +221,7 @@ export class ExtendedAdapter extends BaseAdapter<
           },
         },
         {
+          proofReadableId: this._depositCallProofReadableId(),
           sanitizer: EXTENDED_SANITIZER,
           call: {
             contractAddress: this.config.extendedContract,
@@ -336,95 +240,8 @@ export class ExtendedAdapter extends BaseAdapter<
     }
   }
 
-  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}`);
@@ -442,95 +259,95 @@ export class ExtendedAdapter extends BaseAdapter<
         return {
           status: false,
           receivedTxnHash: false,
-        }
+        };
       }
       if (amount.lessThanOrEqualTo(0)) {
         logger.error(
-          `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
+          `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.`
+          `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"
+          "Cannot get holdings - unable to validate withdrawal amount",
         );
         return {
           status: false,
           receivedTxnHash: false,
-        }
+        };
       }
 
       const availableForWithdrawal = parseFloat(
-        holdings.availableForWithdrawal
+        holdings.availableForWithdrawal,
       );
       if (
         !Number.isFinite(availableForWithdrawal) ||
         availableForWithdrawal < 0
       ) {
         logger.error(
-          `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
+          `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}`
+          `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`,
         );
         return {
           status: false,
           receivedTxnHash: false,
-        }
+        };
       }
 
       logger.info(
-        `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
+        `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`,
       );
 
       const withdrawalRequest = await this.client.withdrawUSDC(
-        amount.toFixed(2)
+        amount.toFixed(2),
       );
 
       if (withdrawalRequest.status === "OK") {
         const withdrawalStatus = await this.getDepositOrWithdrawalStatus(
           withdrawalRequest.data,
-          AssetOperationType.WITHDRAWAL
+          AssetOperationType.WITHDRAWAL,
         );
         return {
           status: true,
           receivedTxnHash: withdrawalStatus,
-        }
+        };
       }
       logger.error(
-        `Withdrawal request failed with status: ${withdrawalRequest.status}`
+        `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,
-      }
+      };
     }
   }
 
@@ -539,41 +356,36 @@ export class ExtendedAdapter extends BaseAdapter<
   }
 
   async getExtendedDepositAmount(): Promise<Balance | undefined> {
-    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;
-      }
+    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;
+    };
 
-      if (!result.data.success) {
-        logger.error(
-          `error getting holdings - API returned status: ${result.status}`
-        );
-        return undefined;
+    try {
+      const result = await this.client.getHoldings();
+      if (result.status !== "OK") {
+        return fail("error getting holdings - API returned null/undefined");
       }
-
-      const holdings = result.data.data;
+      const holdings = result.data;
       if (!holdings) {
-        logger.warn(
-          "holdings data is null/undefined - treating as zero balance"
+        return fail(
+          "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 fail(`error getting holdings - exception: ${error}`);
     }
   }
 
@@ -594,12 +406,14 @@ export class ExtendedAdapter extends BaseAdapter<
 
   async getAllOpenPositions(): Promise<Position[] | null> {
     try {
-      const response = await axios.get<ApiResponse<Position[]>>(`${this.config.extendedBackendReadUrl}/positions`);
-      if (response.data.success) {
-        if (response.data.data.length === 0) {
+      const response = await this.client.getPositions(
+        this.config.extendedMarketName,
+      );
+      if (response.status === "OK") {
+        if (response.data.length === 0) {
           return [];
         } else {
-          return response.data.data;
+          return response.data;
         }
       }
       return null;
@@ -609,41 +423,44 @@ export class ExtendedAdapter extends BaseAdapter<
     }
   }
 
-  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 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
+    marketName: string,
   ): Promise<OpenOrder | null> {
     try {
       if (this.client === null) {
         logger.error("error initializing client");
         return null;
       }
-      const orderhistory = await this.getOrderHistory(marketName);
+      const orderhistoryResponse =
+        await this.client.getOrderHistory(marketName);
 
-      if (!orderhistory || orderhistory.length === 0) {
+      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}`);
@@ -651,14 +468,14 @@ export class ExtendedAdapter extends BaseAdapter<
     }
   }
 
-  async fetchOrderBookBTCUSDC(): Promise<{
+  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`
+        `${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);
@@ -676,12 +493,12 @@ export class ExtendedAdapter extends BaseAdapter<
       bid_price = new Web3Number(bid.price, 0);
 
       return {
-        status: false,
+        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(`the err is: ${err}`);
+      logger.error(`extended orderbook fetch failed: ${err}`);
       return {
         status: false,
         bid: new Web3Number(0, 0),
@@ -695,7 +512,7 @@ export class ExtendedAdapter extends BaseAdapter<
     btcAmount: number,
     side: OrderSide,
     attempt = 1,
-    maxAttempts = 5
+    maxAttempts = 5,
   ): Promise<{ position_id: string; btc_exposure: string } | null> {
     try {
       if (this.client === null) {
@@ -704,13 +521,13 @@ export class ExtendedAdapter extends BaseAdapter<
       }
       const setLeverage = await this.setLeverage(
         leverage,
-        this.config.extendedMarketName
+        this.config.extendedMarketName,
       );
       if (!setLeverage) {
         logger.error("error depositing or setting leverage");
         return null;
       }
-      const { ask, bid } = await this.fetchOrderBookBTCUSDC();
+      const { ask, bid } = await this.fetchOrderBookFromExtended();
       if (
         !ask ||
         !bid ||
@@ -718,7 +535,7 @@ export class ExtendedAdapter extends BaseAdapter<
         bid.lessThanOrEqualTo(0)
       ) {
         logger.error(
-          `Invalid orderbook prices: ask=${ask?.toNumber()}, bid=${bid?.toNumber()}`
+          `Invalid orderbook prices: ask=${ask?.toNumber()}, bid=${bid?.toNumber()}`,
         );
         return null;
       }
@@ -729,7 +546,7 @@ export class ExtendedAdapter extends BaseAdapter<
       const MAX_PRICE_DEVIATION_MULTIPLIER = 0.5;
       const priceAdjustmentMultiplier = Math.min(
         0.2 * attempt,
-        MAX_PRICE_DEVIATION_MULTIPLIER
+        MAX_PRICE_DEVIATION_MULTIPLIER,
       );
       const priceAdjustment = spread.times(priceAdjustmentMultiplier);
 
@@ -747,7 +564,7 @@ export class ExtendedAdapter extends BaseAdapter<
           `Price deviation too large on attempt ${attempt}: price=${price.toNumber()}, midPrice=${midPrice.toNumber()}, deviation=${price
             .minus(midPrice)
             .abs()
-            .toNumber()}`
+            .toNumber()}`,
         );
         if (attempt >= maxAttempts) {
           return null;
@@ -760,11 +577,11 @@ export class ExtendedAdapter extends BaseAdapter<
 
       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
+        this.config.extendedPrecision,
       ); // gives the amount of wbtc
 
       const result = await this.createExtendedPositon(
@@ -772,7 +589,7 @@ export class ExtendedAdapter extends BaseAdapter<
         this.config.extendedMarketName,
         amount_in_token,
         price.toFixed(0),
-        side
+        side,
       );
       if (!result || !result.position_id) {
         logger.error("Failed to create order - no position_id returned");
@@ -781,19 +598,19 @@ export class ExtendedAdapter extends BaseAdapter<
 
       const positionId = result.position_id;
       logger.info(
-        `Order created with position_id: ${positionId}. Waiting for API to update...`
+        `Order created with position_id: ${positionId}. Waiting for API to update...`,
       );
 
       let openOrder = await this.getOrderStatus(
         positionId,
-        this.config.extendedMarketName
+        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)...`
+          `Order ${positionId} not found in API yet. Retrying status fetch (max ${maxStatusRetries} times)...`,
         );
         for (
           let statusRetry = 1;
@@ -803,23 +620,23 @@ export class ExtendedAdapter extends BaseAdapter<
           await new Promise((resolve) => setTimeout(resolve, statusRetryDelay));
           openOrder = await this.getOrderStatus(
             positionId,
-            this.config.extendedMarketName
+            this.config.extendedMarketName,
           );
           if (openOrder) {
             logger.info(
-              `Order ${positionId} found after ${statusRetry} status retry(ies)`
+              `Order ${positionId} found after ${statusRetry} status retry(ies)`,
             );
             break;
           }
           logger.warn(
-            `Order ${positionId} still not found after ${statusRetry}/${maxStatusRetries} status retries`
+            `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}`
+          `Order ${positionId} successfully filled with quantity ${openOrder.qty}`,
         );
         return {
           position_id: positionId,
@@ -828,11 +645,11 @@ export class ExtendedAdapter extends BaseAdapter<
       } 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...`
+          `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`
+            `Max retries reached — order ${positionId} status is ${openOrder.status}, not FILLED`,
           );
           return null;
         } else {
@@ -843,12 +660,12 @@ export class ExtendedAdapter extends BaseAdapter<
             btcAmount,
             side,
             attempt + 1,
-            maxAttempts
+            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.`
+          `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,
@@ -857,7 +674,7 @@ export class ExtendedAdapter extends BaseAdapter<
       }
     } catch (err: any) {
       logger.error(
-        `createShortOrder failed on attempt ${attempt}: ${err.message}`
+        `createShortOrder failed on attempt ${attempt}: ${err.message}`,
       );
 
       if (attempt < maxAttempts) {
@@ -869,7 +686,7 @@ export class ExtendedAdapter extends BaseAdapter<
           btcAmount,
           side,
           attempt + 1,
-          maxAttempts
+          maxAttempts,
         );
       }
       logger.error("Max retry attempts reached — aborting createShortOrder");
@@ -882,17 +699,19 @@ export class ExtendedAdapter extends BaseAdapter<
     marketName: string,
     amount: string,
     price: string,
-    side: OrderSide
+    side: OrderSide,
   ) {
     try {
       const result =
         side === OrderSide.SELL
           ? await client.createSellOrder(marketName, amount, price, {
             postOnly: false,
+            reduceOnly: false,
             timeInForce: TimeInForce.IOC,
           })
           : await client.createBuyOrder(marketName, amount, price, {
             postOnly: false,
+            reduceOnly: true,
             timeInForce: TimeInForce.IOC,
           });
       if (result.data.id) {
@@ -910,7 +729,7 @@ export class ExtendedAdapter extends BaseAdapter<
 
   async getDepositOrWithdrawalStatus(
     orderId: number | string, // for deposits, send txn hash as string
-    operationsType: AssetOperationType
+    operationsType: AssetOperationType,
   ): Promise<boolean> {
     const maxAttempts = 15;
     const retryDelayMs = 30000; // 60 seconds
@@ -923,80 +742,80 @@ export class ExtendedAdapter extends BaseAdapter<
         });
         if (operationsType === AssetOperationType.DEPOSIT) {
           const myTransferStatus = transferHistory.data.find(
-            (operation) => operation.transactionHash?.toLowerCase() === orderId.toString().toLowerCase()
+            (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})...`
+                `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`
+              `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`
-            );
+            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})...`
+                `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`
+              `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()
+            (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})...`
+                `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`
+              `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`
+              `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})...`
+                `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`
+              `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}`
+          `error getting deposit or withdrawal status (attempt ${attempt}/${maxAttempts}): ${err}`,
         );
         if (attempt < maxAttempts) {
           logger.info(`Retrying after ${retryDelayMs}ms...`);
@@ -1004,7 +823,7 @@ export class ExtendedAdapter extends BaseAdapter<
           continue;
         }
         logger.error(
-          `Max retry attempts reached for getDepositOrWithdrawalStatus`
+          `Max retry attempts reached for getDepositOrWithdrawalStatus`,
         );
         return false;
       }