@strkfarm/sdk 2.0.0-dev.13 → 2.0.0-dev.15

package/dist/index.js

@@ -43,6 +43,7 @@ __export(index_exports, {
   AssetOperationStatus: () => AssetOperationStatus,
   AssetOperationType: () => AssetOperationType,
   AutoCompounderSTRK: () => AutoCompounderSTRK,
+  AvnuAdapter: () => AvnuAdapter,
   AvnuWrapper: () => AvnuWrapper,
   BaseAdapter: () => BaseAdapter,
   BaseStrategy: () => BaseStrategy,
@@ -126,6 +127,7 @@ __export(index_exports, {
   calculateExtendedLevergae: () => calculateExtendedLevergae,
   calculateVesUPositionSizeGivenExtended: () => calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage: () => calculateVesuLeverage,
+  calculateWBTCAmountToMaintainLTV: () => calculateWBTCAmountToMaintainLTV,
   extensionMap: () => extensionMap,
   getAPIUsingHeadlessBrowser: () => getAPIUsingHeadlessBrowser,
   getContractDetails: () => getContractDetails,
@@ -28351,6 +28353,21 @@ var calculateAmountDepositOnExtendedWhenIncurringLosses = async (client) => {
     return null;
   }
 };
+var calculateWBTCAmountToMaintainLTV = (collateralAmount, debtAmount, debtPrice, maxLtv = MAX_LIQUIDATION_RATIO, collateralPrice, targetHF = TARGET_HF) => {
+  try {
+    const numerator1 = collateralAmount.multipliedBy(collateralPrice).multipliedBy(maxLtv);
+    const numerator2 = debtAmount.multipliedBy(debtPrice).multipliedBy(targetHF);
+    const denominator = maxLtv;
+    const collateralAmountToMaintainLTV = numerator2.minus(numerator1).dividedBy(denominator);
+    let deltaCollateralAmountUnits = new Web3Number(
+      collateralAmountToMaintainLTV.dividedBy(collateralPrice).toFixed(WBTC_TOKEN_DECIMALS),
+      WBTC_TOKEN_DECIMALS
+    );
+    return { deltaCollateralAmountUnits };
+  } catch (err) {
+    return { deltaCollateralAmountUnits: null };
+  }
+};
 var calculateExposureDelta = (exposure_extended, exposure_vesu) => {
   const exposure_delta = new Web3Number(exposure_extended - exposure_vesu, 2);
   return exposure_delta.absoluteValue().toNumber();
@@ -30090,26 +30107,38 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
     try {
       if (!this.client) {
         logger.error("Client not initialized");
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       if (amount.lessThanOrEqualTo(0)) {
         logger.error(
           `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
         );
-        return false;
+        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 false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       const holdings = await this.getExtendedDepositAmount();
       if (!holdings) {
         logger.error(
           "Cannot get holdings - unable to validate withdrawal amount"
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       const availableForWithdrawal = parseFloat(
         holdings.availableForWithdrawal
@@ -30118,14 +30147,20 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
         logger.error(
           `Invalid availableForWithdrawal: ${holdings.availableForWithdrawal}. Expected a finite, non-negative number.`
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       const withdrawalAmount = amount.toNumber();
       if (withdrawalAmount > availableForWithdrawal) {
         logger.error(
           `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
       logger.info(
         `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
@@ -30138,15 +30173,24 @@ var ExtendedAdapter = class _ExtendedAdapter extends BaseAdapter {
           withdrawalRequest.data,
           "WITHDRAWAL" /* WITHDRAWAL */
         );
-        return withdrawalStatus;
+        return {
+          status: true,
+          receivedTxnHash: withdrawalStatus
+        };
       }
       logger.error(
         `Withdrawal request failed with status: ${withdrawalRequest.status}`
       );
-      return false;
+      return {
+        status: false,
+        receivedTxnHash: false
+      };
     } catch (error) {
       logger.error(`Error creating Withdraw Call: ${error}`);
-      return false;
+      return {
+        status: false,
+        receivedTxnHash: false
+      };
     }
   }
   async getHealthFactor() {
@@ -30632,6 +30676,336 @@ var UnusedBalanceAdapter = class _UnusedBalanceAdapter extends BaseAdapter {
   }
 };
 
+// src/strategies/universal-adapters/avnu-adapter.ts
+var import_starknet23 = require("starknet");
+var import_axios9 = __toESM(require("axios"));
+var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
+  constructor(config) {
+    super(config, _AvnuAdapter.name, Protocols.AVNU);
+    this.config = config;
+    this.avnuWrapper = new AvnuWrapper();
+  }
+  //abstract means the method has no implementation in this class; instead, child classes must implement it.
+  async getAPY(supportedPosition) {
+    return Promise.resolve({ apy: 0, type: "base" /* BASE */ });
+  }
+  async getPosition(supportedPosition) {
+    return Promise.resolve({ amount: new Web3Number(0, 0), remarks: "" });
+  }
+  async maxDeposit(amount) {
+    return Promise.resolve({
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, 0),
+      usdValue: 0,
+      apy: { apy: 0, type: "base" /* BASE */ },
+      protocol: Protocols.AVNU,
+      remarks: ""
+    });
+  }
+  async maxWithdraw() {
+    return Promise.resolve({
+      tokenInfo: this.config.baseToken,
+      amount: new Web3Number(0, 0),
+      usdValue: 0,
+      apy: { apy: 0, type: "base" /* BASE */ },
+      protocol: Protocols.AVNU,
+      remarks: ""
+    });
+  }
+  _getDepositLeaf() {
+    const vaultAllocator = ContractAddr.from(
+      this.config.vaultAllocator.address
+    );
+    return [
+      {
+        target: this.config.supportedPositions[0].asset.address,
+        method: "approve",
+        packedArguments: [
+          AVNU_EXCHANGE.toBigInt()
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_${this.config.supportedPositions[0].asset.symbol}`
+      },
+      {
+        target: AVNU_EXCHANGE,
+        method: "multi_route_swap",
+        packedArguments: [
+          this.config.supportedPositions[0].asset.address.toBigInt(),
+          //usdc
+          this.config.supportedPositions[1].asset.address.toBigInt(),
+          //wbtc
+          vaultAllocator.toBigInt()
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `asutb_${this.config.supportedPositions[0].asset.symbol}_${this.config.supportedPositions[1].asset.symbol}`
+      }
+    ];
+  }
+  _getWithdrawLeaf() {
+    const vaultAllocator = ContractAddr.from(
+      this.config.vaultAllocator.address
+    );
+    const toToken = this.config.supportedPositions[0].asset;
+    const fromToken = this.config.supportedPositions[1].asset;
+    return [
+      {
+        target: fromToken.address,
+        method: "approve",
+        packedArguments: [
+          AVNU_EXCHANGE.toBigInt()
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `approve_${fromToken.symbol}`
+      },
+      {
+        target: AVNU_EXCHANGE,
+        method: "multi_route_swap",
+        packedArguments: [
+          fromToken.address.toBigInt(),
+          //wbtc
+          toToken.address.toBigInt(),
+          //usdc
+          vaultAllocator.toBigInt()
+        ],
+        sanitizer: SIMPLE_SANITIZER,
+        id: `asbtu_${fromToken.symbol}_${fromToken.symbol}`
+      }
+    ];
+  }
+  _getLegacySwapLeaf() {
+    return [];
+  }
+  async getDepositCall(params) {
+    try {
+      const fromToken = this.config.supportedPositions[0].asset;
+      const toToken = this.config.supportedPositions[1].asset;
+      const vaultAllocator = ContractAddr.from(
+        this.config.vaultAllocator.address
+      );
+      const quote = await this.getQuotesAvnu(
+        fromToken.address.toString(),
+        toToken.address.toString(),
+        params.amount.toNumber(),
+        vaultAllocator.address.toString(),
+        toToken.decimals,
+        true
+      );
+      if (!quote) {
+        logger.error("error getting quote from avnu");
+        return [];
+      }
+      const getCalldata = await this.avnuWrapper.getSwapCallData(
+        quote,
+        vaultAllocator.address
+      );
+      const swapCallData = getCalldata[0];
+      const amount = import_starknet23.uint256.bnToUint256(quote.sellAmountInUsd * 10 ** 7);
+      return [
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: fromToken.address,
+            selector: import_starknet23.hash.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE.toBigInt(),
+              toBigInt(amount.low.toString()),
+              // amount low
+              toBigInt(amount.high.toString())
+              // amount high
+            ]
+          }
+        },
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE,
+            selector: import_starknet23.hash.getSelectorFromName("multi_route_swap"),
+            calldata: swapCallData
+          }
+        }
+      ];
+    } catch (error) {
+      logger.error(`Error getting Avnu quote: ${error}`);
+      return [];
+    }
+  }
+  //Swap wbtc to usdc
+  async getWithdrawCall(params) {
+    try {
+      const toToken = this.config.supportedPositions[0].asset;
+      const fromToken = this.config.supportedPositions[1].asset;
+      const vaultAllocator = ContractAddr.from(
+        this.config.vaultAllocator.address
+      );
+      const quote = await this.getQuotesAvnu(
+        fromToken.address.toString(),
+        toToken.address.toString(),
+        params.amount.toNumber(),
+        vaultAllocator.address.toString(),
+        fromToken.decimals,
+        false
+      );
+      if (!quote) {
+        logger.error("No quotes available for this swap, error in quotes avnu");
+        return [];
+      }
+      const getCalldata = await this.avnuWrapper.getSwapCallData(
+        quote,
+        vaultAllocator.address
+      );
+      const swapCallData = getCalldata[0];
+      const amount = import_starknet23.uint256.bnToUint256(params.amount.toWei());
+      return [
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: fromToken.address,
+            selector: import_starknet23.hash.getSelectorFromName("approve"),
+            calldata: [
+              AVNU_EXCHANGE.toBigInt(),
+              toBigInt(amount.low.toString()),
+              // amount low
+              toBigInt(amount.high.toString())
+              // amount high
+            ]
+          }
+        },
+        {
+          sanitizer: SIMPLE_SANITIZER,
+          call: {
+            contractAddress: AVNU_EXCHANGE,
+            selector: import_starknet23.hash.getSelectorFromName("multi_route_swap"),
+            calldata: swapCallData
+          }
+        }
+      ];
+    } catch (error) {
+      logger.error(`Error getting Avnu quote: ${error}`);
+      return [];
+    }
+  }
+  async getSwapCallData(quote) {
+    return await this.avnuWrapper.getSwapCallData(quote, this.config.vaultAllocator.address);
+  }
+  async getHealthFactor() {
+    return Promise.resolve(1);
+  }
+  async fetchQuoteWithRetry(params, retries = 5) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const response = await import_axios9.default.get(this.config.baseUrl, { params });
+        if (response.data && response.data.length > 0) {
+          return response;
+        }
+        throw new Error("Empty response data");
+      } catch (err) {
+        logger.error(`Error fetching quote with retry: ${err}`);
+        if (attempt === retries - 1) {
+          throw err;
+        }
+        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
+      }
+    }
+    throw new Error("Failed to fetch quote after retries");
+  }
+  async getQuotesAvnu(from_token_address, to_token_address, amount, takerAddress, toTokenDecimals, usdcToBtc, maxIterations = 5, tolerance = 5e3) {
+    try {
+      const fromToken = this.config.supportedPositions[0].asset;
+      const toToken = this.config.supportedPositions[1].asset;
+      if (!usdcToBtc) {
+        const sellAmount2 = returnFormattedAmount(amount, toTokenDecimals);
+        const params2 = {
+          sellTokenAddress: from_token_address,
+          buyTokenAddress: to_token_address,
+          takerAddress,
+          sellAmount: sellAmount2
+        };
+        const finalQuote2 = await this.fetchQuoteWithRetry(params2);
+        if (!finalQuote2.data.length) {
+          logger.error("No quotes available for this swap, error in quotes avnu");
+          return null;
+        }
+        const dataObject2 = finalQuote2.data[0];
+        return dataObject2;
+      }
+      const btcPrice = await this.getPriceOfToken(toToken.address.toString());
+      if (!btcPrice) {
+        logger.error(`error getting btc price: ${btcPrice}`);
+        return null;
+      }
+      const estimatedUsdcAmount = Math.floor(amount * btcPrice);
+      const targetBtcBig = BigInt(returnFormattedAmount(amount, toTokenDecimals));
+      let low = BigInt(
+        Math.floor(
+          estimatedUsdcAmount * 10 ** fromToken.decimals * 0.9
+        )
+      );
+      let high = BigInt(
+        Math.floor(
+          estimatedUsdcAmount * 10 ** fromToken.decimals * 1.1
+        )
+      );
+      let mid = 0n;
+      for (let i = 0; i < maxIterations; i++) {
+        mid = (low + high) / 2n;
+        const sellAmount2 = returnFormattedAmount(Number(mid), 0);
+        const quote = await this.fetchQuoteWithRetry({
+          sellTokenAddress: from_token_address,
+          buyTokenAddress: to_token_address,
+          takerAddress,
+          sellAmount: sellAmount2
+        });
+        const gotBtc = BigInt(quote.data[0].buyAmount);
+        if (gotBtc === targetBtcBig) return quote.data[0];
+        if (gotBtc > targetBtcBig) {
+          high = mid;
+        } else {
+          low = mid;
+        }
+        if (gotBtc >= targetBtcBig && gotBtc <= targetBtcBig + BigInt(tolerance)) {
+          return quote.data[0];
+        }
+      }
+      let sellAmount = returnFormattedAmount(
+        Number(mid),
+        0
+      );
+      const params = {
+        sellTokenAddress: from_token_address,
+        buyTokenAddress: to_token_address,
+        takerAddress,
+        sellAmount
+      };
+      const finalQuote = await this.fetchQuoteWithRetry(params);
+      if (!finalQuote.data.length) {
+        logger.error("No quotes available for this swap, error in quotes avnu");
+        return null;
+      }
+      const dataObject = finalQuote.data[0];
+      return dataObject;
+    } catch (err) {
+      logger.error(`No quotes available for this swap: ${err}`);
+      return null;
+    }
+  }
+  async getPriceOfToken(tokenAddress, retries = MAX_RETRIES) {
+    try {
+      const url = `https://starknet.impulse.avnu.fi/v1/tokens/${tokenAddress}/prices/line`;
+      const response = await import_axios9.default.get(url);
+      const length = response.data.length;
+      return response.data[length - 1].value;
+    } catch (err) {
+      if (retries > 0) {
+        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
+        return this.getPriceOfToken(tokenAddress, retries - 1);
+      } else {
+        logger.error(`Failed to fetch price for ${tokenAddress} after ${MAX_RETRIES} attempts`);
+        return null;
+      }
+    }
+  }
+};
+
 // src/strategies/universal-strategy.tsx
 var AUMTypes = /* @__PURE__ */ ((AUMTypes2) => {
   AUMTypes2["FINALISED"] = "finalised";
@@ -30670,7 +31044,7 @@ function getContractDetails(settings) {
 }
 
 // src/strategies/svk-strategy.ts
-var import_starknet23 = require("starknet");
+var import_starknet24 = require("starknet");
 
 // src/data/universal-vault.abi.json
 var universal_vault_abi_default = [
@@ -32997,12 +33371,12 @@ var SVKStrategy = class extends BaseStrategy {
     this.pricer = pricer;
     this.metadata = metadata;
     this.address = metadata.address;
-    this.contract = new import_starknet23.Contract({
+    this.contract = new import_starknet24.Contract({
       abi: universal_vault_abi_default,
       address: this.address.address,
       providerOrAccount: this.config.provider
     });
-    this.managerContract = new import_starknet23.Contract({
+    this.managerContract = new import_starknet24.Contract({
       abi: vault_manager_abi_default,
       address: this.metadata.additionalInfo.manager.address,
       providerOrAccount: this.config.provider
@@ -33115,7 +33489,7 @@ var SVKStrategy = class extends BaseStrategy {
   getSetManagerCall(strategist, root = this.getMerkleRoot()) {
     return this.managerContract.populate("set_manage_root", [
       strategist.address,
-      import_starknet23.num.getHexString(root)
+      import_starknet24.num.getHexString(root)
     ]);
   }
   /**
@@ -34053,336 +34427,6 @@ var HyperLSTStrategies = [
   getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
 ];
 
-// src/strategies/universal-adapters/avnu-adapter.ts
-var import_starknet24 = require("starknet");
-var import_axios9 = __toESM(require("axios"));
-var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
-  constructor(config) {
-    super(config, _AvnuAdapter.name, Protocols.AVNU);
-    this.config = config;
-    this.avnuWrapper = new AvnuWrapper();
-  }
-  //abstract means the method has no implementation in this class; instead, child classes must implement it.
-  async getAPY(supportedPosition) {
-    return Promise.resolve({ apy: 0, type: "base" /* BASE */ });
-  }
-  async getPosition(supportedPosition) {
-    return Promise.resolve({ amount: new Web3Number(0, 0), remarks: "" });
-  }
-  async maxDeposit(amount) {
-    return Promise.resolve({
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, 0),
-      usdValue: 0,
-      apy: { apy: 0, type: "base" /* BASE */ },
-      protocol: Protocols.AVNU,
-      remarks: ""
-    });
-  }
-  async maxWithdraw() {
-    return Promise.resolve({
-      tokenInfo: this.config.baseToken,
-      amount: new Web3Number(0, 0),
-      usdValue: 0,
-      apy: { apy: 0, type: "base" /* BASE */ },
-      protocol: Protocols.AVNU,
-      remarks: ""
-    });
-  }
-  _getDepositLeaf() {
-    const vaultAllocator = ContractAddr.from(
-      this.config.vaultAllocator.address
-    );
-    return [
-      {
-        target: this.config.supportedPositions[0].asset.address,
-        method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE.toBigInt()
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `approve_${this.config.supportedPositions[0].asset.symbol}`
-      },
-      {
-        target: AVNU_EXCHANGE,
-        method: "multi_route_swap",
-        packedArguments: [
-          this.config.supportedPositions[0].asset.address.toBigInt(),
-          //usdc
-          this.config.supportedPositions[1].asset.address.toBigInt(),
-          //wbtc
-          vaultAllocator.toBigInt()
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `asutb_${this.config.supportedPositions[0].asset.symbol}_${this.config.supportedPositions[1].asset.symbol}`
-      }
-    ];
-  }
-  _getWithdrawLeaf() {
-    const vaultAllocator = ContractAddr.from(
-      this.config.vaultAllocator.address
-    );
-    const toToken = this.config.supportedPositions[0].asset;
-    const fromToken = this.config.supportedPositions[1].asset;
-    return [
-      {
-        target: fromToken.address,
-        method: "approve",
-        packedArguments: [
-          AVNU_EXCHANGE.toBigInt()
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `approve_${fromToken.symbol}`
-      },
-      {
-        target: AVNU_EXCHANGE,
-        method: "multi_route_swap",
-        packedArguments: [
-          fromToken.address.toBigInt(),
-          //wbtc
-          toToken.address.toBigInt(),
-          //usdc
-          vaultAllocator.toBigInt()
-        ],
-        sanitizer: SIMPLE_SANITIZER,
-        id: `asbtu_${fromToken.symbol}_${fromToken.symbol}`
-      }
-    ];
-  }
-  _getLegacySwapLeaf() {
-    return [];
-  }
-  async getDepositCall(params) {
-    try {
-      const fromToken = this.config.supportedPositions[0].asset;
-      const toToken = this.config.supportedPositions[1].asset;
-      const vaultAllocator = ContractAddr.from(
-        this.config.vaultAllocator.address
-      );
-      const quote = await this.getQuotesAvnu(
-        fromToken.address.toString(),
-        toToken.address.toString(),
-        params.amount.toNumber(),
-        vaultAllocator.address.toString(),
-        toToken.decimals,
-        true
-      );
-      if (!quote) {
-        logger.error("error getting quote from avnu");
-        return [];
-      }
-      const getCalldata = await this.avnuWrapper.getSwapCallData(
-        quote,
-        vaultAllocator.address
-      );
-      const swapCallData = getCalldata[0];
-      const amount = import_starknet24.uint256.bnToUint256(quote.sellAmountInUsd * 10 ** 7);
-      return [
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: fromToken.address,
-            selector: import_starknet24.hash.getSelectorFromName("approve"),
-            calldata: [
-              AVNU_EXCHANGE.toBigInt(),
-              toBigInt(amount.low.toString()),
-              // amount low
-              toBigInt(amount.high.toString())
-              // amount high
-            ]
-          }
-        },
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: AVNU_EXCHANGE,
-            selector: import_starknet24.hash.getSelectorFromName("multi_route_swap"),
-            calldata: swapCallData
-          }
-        }
-      ];
-    } catch (error) {
-      logger.error(`Error getting Avnu quote: ${error}`);
-      return [];
-    }
-  }
-  //Swap wbtc to usdc
-  async getWithdrawCall(params) {
-    try {
-      const toToken = this.config.supportedPositions[0].asset;
-      const fromToken = this.config.supportedPositions[1].asset;
-      const vaultAllocator = ContractAddr.from(
-        this.config.vaultAllocator.address
-      );
-      const quote = await this.getQuotesAvnu(
-        fromToken.address.toString(),
-        toToken.address.toString(),
-        params.amount.toNumber(),
-        vaultAllocator.address.toString(),
-        fromToken.decimals,
-        false
-      );
-      if (!quote) {
-        logger.error("No quotes available for this swap, error in quotes avnu");
-        return [];
-      }
-      const getCalldata = await this.avnuWrapper.getSwapCallData(
-        quote,
-        vaultAllocator.address
-      );
-      const swapCallData = getCalldata[0];
-      const amount = import_starknet24.uint256.bnToUint256(params.amount.toWei());
-      return [
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: fromToken.address,
-            selector: import_starknet24.hash.getSelectorFromName("approve"),
-            calldata: [
-              AVNU_EXCHANGE.toBigInt(),
-              toBigInt(amount.low.toString()),
-              // amount low
-              toBigInt(amount.high.toString())
-              // amount high
-            ]
-          }
-        },
-        {
-          sanitizer: SIMPLE_SANITIZER,
-          call: {
-            contractAddress: AVNU_EXCHANGE,
-            selector: import_starknet24.hash.getSelectorFromName("multi_route_swap"),
-            calldata: swapCallData
-          }
-        }
-      ];
-    } catch (error) {
-      logger.error(`Error getting Avnu quote: ${error}`);
-      return [];
-    }
-  }
-  async getSwapCallData(quote) {
-    return await this.avnuWrapper.getSwapCallData(quote, this.config.vaultAllocator.address);
-  }
-  async getHealthFactor() {
-    return Promise.resolve(1);
-  }
-  async fetchQuoteWithRetry(params, retries = 5) {
-    for (let attempt = 0; attempt < retries; attempt++) {
-      try {
-        const response = await import_axios9.default.get(this.config.baseUrl, { params });
-        if (response.data && response.data.length > 0) {
-          return response;
-        }
-        throw new Error("Empty response data");
-      } catch (err) {
-        logger.error(`Error fetching quote with retry: ${err}`);
-        if (attempt === retries - 1) {
-          throw err;
-        }
-        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
-      }
-    }
-    throw new Error("Failed to fetch quote after retries");
-  }
-  async getQuotesAvnu(from_token_address, to_token_address, amount, takerAddress, toTokenDecimals, usdcToBtc, maxIterations = 5, tolerance = 5e3) {
-    try {
-      const fromToken = this.config.supportedPositions[0].asset;
-      const toToken = this.config.supportedPositions[1].asset;
-      if (!usdcToBtc) {
-        const sellAmount2 = returnFormattedAmount(amount, toTokenDecimals);
-        const params2 = {
-          sellTokenAddress: from_token_address,
-          buyTokenAddress: to_token_address,
-          takerAddress,
-          sellAmount: sellAmount2
-        };
-        const finalQuote2 = await this.fetchQuoteWithRetry(params2);
-        if (!finalQuote2.data.length) {
-          logger.error("No quotes available for this swap, error in quotes avnu");
-          return null;
-        }
-        const dataObject2 = finalQuote2.data[0];
-        return dataObject2;
-      }
-      const btcPrice = await this.getPriceOfToken(toToken.address.toString());
-      if (!btcPrice) {
-        logger.error(`error getting btc price: ${btcPrice}`);
-        return null;
-      }
-      const estimatedUsdcAmount = Math.floor(amount * btcPrice);
-      const targetBtcBig = BigInt(returnFormattedAmount(amount, toTokenDecimals));
-      let low = BigInt(
-        Math.floor(
-          estimatedUsdcAmount * 10 ** fromToken.decimals * 0.9
-        )
-      );
-      let high = BigInt(
-        Math.floor(
-          estimatedUsdcAmount * 10 ** fromToken.decimals * 1.1
-        )
-      );
-      let mid = 0n;
-      for (let i = 0; i < maxIterations; i++) {
-        mid = (low + high) / 2n;
-        const sellAmount2 = returnFormattedAmount(Number(mid), 0);
-        const quote = await this.fetchQuoteWithRetry({
-          sellTokenAddress: from_token_address,
-          buyTokenAddress: to_token_address,
-          takerAddress,
-          sellAmount: sellAmount2
-        });
-        const gotBtc = BigInt(quote.data[0].buyAmount);
-        if (gotBtc === targetBtcBig) return quote.data[0];
-        if (gotBtc > targetBtcBig) {
-          high = mid;
-        } else {
-          low = mid;
-        }
-        if (gotBtc >= targetBtcBig && gotBtc <= targetBtcBig + BigInt(tolerance)) {
-          return quote.data[0];
-        }
-      }
-      let sellAmount = returnFormattedAmount(
-        Number(mid),
-        0
-      );
-      const params = {
-        sellTokenAddress: from_token_address,
-        buyTokenAddress: to_token_address,
-        takerAddress,
-        sellAmount
-      };
-      const finalQuote = await this.fetchQuoteWithRetry(params);
-      if (!finalQuote.data.length) {
-        logger.error("No quotes available for this swap, error in quotes avnu");
-        return null;
-      }
-      const dataObject = finalQuote.data[0];
-      return dataObject;
-    } catch (err) {
-      logger.error(`No quotes available for this swap: ${err}`);
-      return null;
-    }
-  }
-  async getPriceOfToken(tokenAddress, retries = MAX_RETRIES) {
-    try {
-      const url = `https://starknet.impulse.avnu.fi/v1/tokens/${tokenAddress}/prices/line`;
-      const response = await import_axios9.default.get(url);
-      const length = response.data.length;
-      return response.data[length - 1].value;
-    } catch (err) {
-      if (retries > 0) {
-        await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
-        return this.getPriceOfToken(tokenAddress, retries - 1);
-      } else {
-        logger.error(`Failed to fetch price for ${tokenAddress} after ${MAX_RETRIES} attempts`);
-        return null;
-      }
-    }
-  }
-};
-
 // src/strategies/vesu-extended-strategy/vesu-extended-strategy.tsx
 var import_jsx_runtime5 = require("react/jsx-runtime");
 var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy extends SVKStrategy {
@@ -34499,10 +34543,16 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         proofGroups,
         await proofsInfo.callConstructor({ amount })
       );
-      return [approveCall, transferCall, call];
+      return {
+        calls: [approveCall, transferCall, call],
+        status: true
+      };
     } catch (err) {
       logger.error(`error moving assets to vault allocator: ${err}`);
-      return [];
+      return {
+        calls: [],
+        status: false
+      };
     }
   }
   async shouldInvest() {
@@ -34751,9 +34801,10 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
       logger.info(`${_VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculated movements - Extended withdrawal: ${totalExtendedWithdrawal.toNumber()}, Extended deposit: ${totalExtendedDeposit.toNumber()}, Extended diff: ${extendedAmountDifference.toNumber()}, Projected wallet: ${projectedWalletBalance.toNumber()}, Vesu diff: ${vesuAmountDifference.toNumber()}`);
       let calls = [];
+      let transactionResults = [];
       if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         try {
-          const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+          const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
             {
               to: Protocols.VAULT.name,
               from: Protocols.EXTENDED.name,
@@ -34763,17 +34814,25 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             vesuAdapter
           );
           if (extendedStatus) {
-            calls.push(...extendedCalls);
+            transactionResults.push({
+              status: extendedStatus,
+              calls: extendedCalls,
+              transactionMetadata: {
+                ...extendedTransactionMetadata,
+                transactionType: "DEPOSIT"
+              }
+            });
           } else {
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE")];
           }
         } catch (err) {
           logger.error(`Failed moving assets to vault: ${err}`);
+          return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE")];
         }
       }
       if (vesuAmount.isNegative() && vesuAmount.abs().greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
         try {
-          const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+          const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
             {
               to: Protocols.EXTENDED.name,
               from: Protocols.VESU.name,
@@ -34782,18 +34841,26 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             extendedAdapter,
             vesuAdapter
           );
-          calls.push(...vesuCalls);
           if (!vesuStatus) {
-            return [];
-          }
+            return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE")];
+          }
+          transactionResults.push({
+            status: vesuStatus,
+            calls: vesuCalls,
+            transactionMetadata: {
+              ...vesuTransactionMetadata,
+              transactionType: "DEPOSIT"
+            }
+          });
         } catch (err) {
-          logger.error(`Failed moving assets to vault: ${err}`);
+          logger.error(`Failed moving assets to extended via vault allocator: ${err}`);
+          return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE")];
         }
       }
       if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
         if (extendedAmountDifference.greaterThan(0)) {
           try {
-            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
               {
                 to: Protocols.EXTENDED.name,
                 from: Protocols.VAULT.name,
@@ -34803,18 +34870,22 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
               vesuAdapter
             );
             if (extendedStatus) {
-              calls.push(...extendedCalls);
+              transactionResults.push({
+                status: extendedStatus,
+                calls: extendedCalls,
+                transactionMetadata: extendedTransactionMetadata
+              });
             } else {
               logger.error(`Failed to move assets to extended - operation returned false status`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE")];
             }
           } catch (err) {
             logger.error(`Failed moving assets to extended: ${err}`);
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE")];
           }
         } else if (extendedAmountDifference.lessThan(0)) {
           try {
-            const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
@@ -34824,14 +34895,21 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
               vesuAdapter
             );
             if (extendedStatus) {
-              calls.push(...extendedCalls);
+              transactionResults.push({
+                status: extendedStatus,
+                calls: extendedCalls,
+                transactionMetadata: {
+                  ...extendedTransactionMetadata,
+                  transactionType: "DEPOSIT"
+                }
+              });
             } else {
               logger.error(`Failed to withdraw from extended - operation returned false status`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE")];
             }
           } catch (err) {
             logger.error(`Failed moving assets from extended to vault: ${err}`);
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE")];
           }
         }
       }
@@ -34842,7 +34920,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           );
         } else {
           try {
-            const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+            const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
               {
                 to: Protocols.VAULT.name,
                 from: Protocols.EXTENDED.name,
@@ -34853,31 +34931,54 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
             );
             if (!vesuStatus) {
               logger.error(`Failed to move assets to vesu - operation returned false status`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE")];
             }
-            calls.push(...vesuCalls);
+            transactionResults.push({
+              status: vesuStatus,
+              calls: vesuCalls,
+              transactionMetadata: {
+                ...vesuTransactionMetadata,
+                transactionType: "DEPOSIT"
+              }
+            });
           } catch (err) {
             logger.error(`Failed moving assets to vault: ${err}`);
-            return [];
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE")];
           }
         }
       }
-      return calls;
+      return transactionResults;
     } catch (err) {
       logger.error(`Failed moving assets to vesu: ${err}`);
-      return [];
+      return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: new Web3Number(0, USDC_TOKEN_DECIMALS) }, "NONE")];
     }
   }
+  /**
+   * Helper method to create transaction result with metadata
+   */
+  createTransactionResult(calls, status, params, transactionType) {
+    if (status) {
+      return {
+        calls,
+        status,
+        transactionMetadata: {
+          protocolFrom: params.from,
+          protocolTo: params.to,
+          transactionType,
+          usdAmount: params.amount.abs().toFixed(),
+          status: "PENDING"
+        }
+      };
+    }
+    return { calls: [], status: false, transactionMetadata: { protocolFrom: "", protocolTo: "", transactionType: "DEPOSIT", usdAmount: "0", status: "FAILED" } };
+  }
   async moveAssets(params, extendedAdapter, vesuAdapter) {
     try {
       if (params.amount.lessThanOrEqualTo(0)) {
         logger.error(
           `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
         );
-        return {
-          calls: [],
-          status: false
-        };
+        return this.createTransactionResult([], false, params, "NONE");
       }
       const amountAbs = params.amount.abs();
       if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
@@ -34885,10 +34986,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           logger.warn(
             `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
           );
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
       }
       if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
@@ -34896,19 +34994,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           logger.warn(
             `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
           );
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
       }
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return {
-          calls: [],
-          status: false
-        };
+        return this.createTransactionResult([], false, params, "NONE");
       }
       logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
@@ -34927,19 +35019,13 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return {
-          calls: [call],
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "DEPOSIT");
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.EXTENDED.name) {
         const extendedLeverage = calculateExtendedLevergae();
         const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
         if (!extendedHoldings) {
           logger.error(`error getting extended holdings: ${extendedHoldings}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
         const extendedHoldingAmount = new Web3Number(
           extendedHoldings.availableForWithdrawal,
@@ -34966,36 +35052,36 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
           if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
             logger.error(`Insufficient balance after opening position. Available: ${updatedHoldings?.availableForWithdrawal}, Needed: ${params.amount.abs()}`);
-            return { calls: [], status: false };
+            return this.createTransactionResult([], false, params, "NONE");
           }
         }
-        const withdrawalFromExtended = await extendedAdapter.withdrawFromExtended(params.amount);
-        if (withdrawalFromExtended) {
+        const {
+          status: withdrawalFromExtendedStatus,
+          receivedTxnHash: withdrawalFromExtendedTxnHash
+        } = await extendedAdapter.withdrawFromExtended(params.amount);
+        logger.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+        if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
           const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
           logger.info(`extendedHoldings after withdrawal ${extendedHoldings2?.availableForWithdrawal}`);
           await new Promise((resolve) => setTimeout(resolve, 5e3));
-          const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
-          if (calls.length > 0) {
-            return {
-              calls,
-              status: true
-            };
+          const { calls, status } = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
+          if (calls.length > 0 && status) {
+            return this.createTransactionResult(calls, true, params, "WITHDRAWAL");
+          } else {
+            return this.createTransactionResult([], true, params, "WITHDRAWAL");
           }
+        } else if (withdrawalFromExtendedStatus && !withdrawalFromExtendedTxnHash) {
+          logger.error("withdrawal from extended successful, but funds didn't get transferred to the wallet");
+          return this.createTransactionResult([], true, params, "WITHDRAWAL");
         } else {
           logger.error("withdrawal from extended failed");
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
         const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
           logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toFixed(WBTC_TOKEN_DECIMALS),
@@ -35016,18 +35102,12 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return {
-          calls,
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "WITHDRAWAL");
       } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
         const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "close" /* CLOSE */);
         if (!isPriceDifferenceBetweenAvnuAndExtended) {
           logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
@@ -35058,127 +35138,21 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return {
-          calls,
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "DEPOSIT");
       }
-      return {
-        calls: [],
-        status: false
-      };
+      logger.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
+      return this.createTransactionResult([], false, params, "NONE");
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return {
-        calls: [],
-        status: false
-      };
+      return this.createTransactionResult([], false, params, "NONE");
     }
   }
   async handleDeposit() {
     try {
-      const vesuAdapter = await this.getVesuAdapter();
-      const extendedAdapter = await this.getExtendedAdapter();
-      const avnuAdapter = await this.getAvnuAdapter();
-      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client || !avnuAdapter) {
-        logger.error(
-          "vesu or extended adapter not found",
-          vesuAdapter,
-          extendedAdapter
-        );
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedLeverage = calculateExtendedLevergae();
-      const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, "open" /* OPEN */);
-      if (!isPriceDifferenceBetweenAvnuAndExtended) {
-        logger.error("price difference between avnu and extended doesn't fit the range");
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const position = await extendedAdapter.getAllOpenPositions();
-      if (!position) {
-        logger.error("error getting extended position", position);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedPositionValue = position.length > 0 ? parseFloat(position[0].value) : 0;
-      const BUFFER_AMOUNT_IN_AVAILABLE_FOR_TRADE = BUFFER_USDC_IN_WITHDRAWAL;
-      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-      if (!extendedHoldings) {
-        logger.error(`error getting extended holdings: ${extendedHoldings}`);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      const extendedHoldingAmount = new Web3Number(
-        extendedHoldings.availableForWithdrawal,
-        USDC_TOKEN_DECIMALS
-      );
-      const {
-        collateralTokenAmount
-      } = await vesuAdapter.vesuAdapter.getAssetPrices();
-      const { collateralPrice } = await this.getAssetPrices();
-      const { vesuAmountInBTC, extendedAmountInBTC } = calculateVesUPositionSizeGivenExtended(
-        extendedPositionValue,
-        extendedHoldingAmount.minus(BUFFER_AMOUNT_IN_AVAILABLE_FOR_TRADE),
-        collateralTokenAmount,
-        collateralPrice.price
-      );
-      logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
-      let calls = [];
-      if (vesuAmountInBTC.greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
-        const proofsInfo = vesuAdapter.getProofs(true, this.getMerkleTree());
-        const proofGroups = proofsInfo.proofs;
-        const call = this.getManageCall(
-          proofGroups,
-          await proofsInfo.callConstructor({
-            amount: vesuAmountInBTC
-          })
-        );
-        const { amount: wbtcAmountInVaultAllocator } = await this.getUnusedBalanceWBTC();
-        if (wbtcAmountInVaultAllocator.lessThan(vesuAmountInBTC)) {
-          const swapProofsInfo = avnuAdapter.getProofs(true, this.getMerkleTree());
-          const swapProofGroups = swapProofsInfo.proofs;
-          const swapCall = this.getManageCall(
-            swapProofGroups,
-            await swapProofsInfo.callConstructor({
-              amount: vesuAmountInBTC
-            })
-          );
-          calls.push(swapCall);
-        }
-        calls.push(call);
-      }
-      const shortPosition = extendedAmountInBTC.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
-        extendedLeverage.toString(),
-        extendedAmountInBTC.toNumber(),
-        "SELL" /* SELL */
-      ) : null;
-      if (!shortPosition && extendedAmountInBTC.multipliedBy(3).abs().greaterThan(MINIMUM_EXTENDED_POSITION_SIZE)) {
-        logger.error(`error creating short position thus no position to be opened on vesu: ${shortPosition}`);
-        return {
-          extendedAmountInBTC: new Web3Number(0, 0),
-          calls: []
-        };
-      }
-      return {
-        extendedAmountInBTC,
-        calls
-      };
+      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE");
     } catch (err) {
       logger.error(`error handling deposit: ${err}`);
-      return {
-        extendedAmountInBTC: new Web3Number(0, 0),
-        calls: []
-      };
+      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE");
     }
   }
   async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, positionType) {
@@ -35223,12 +35197,8 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         const withdrawCall2 = await this.getBringLiquidityCall({
           amount: usdcBalanceVaultAllocator.amount
         });
-        logger.info("withdraw call", withdrawCall2);
         calls.push(withdrawCall2);
-        return {
-          calls,
-          status: true
-        };
+        return [this.createTransactionResult(calls, true, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "WITHDRAWAL")];
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
@@ -35237,11 +35207,9 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
       }
+      let transactionResults = [];
       const { collateralTokenAmount } = await vesuAdapter.vesuAdapter.getAssetPrices();
       const {
         collateralPrice
@@ -35250,10 +35218,7 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       if (!extendedPositon) {
         status = false;
         logger.error("error getting extended position", extendedPositon);
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
       }
       const amountDistributionForWithdrawal = await calculateAmountDistributionForWithdrawal(
         usdcBalanceDifference,
@@ -35266,14 +35231,11 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return {
-          calls,
-          status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
       }
       const { vesu_amount, extended_amount } = amountDistributionForWithdrawal;
       if (status && vesu_amount.greaterThan(0)) {
-        const { calls: vesuCalls, status: vesuStatus } = await this.moveAssets(
+        const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
           {
             amount: vesu_amount,
             from: Protocols.VESU.name,
@@ -35283,10 +35245,14 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
           vesuAdapter
         );
         status = vesuStatus;
-        calls.push(...vesuCalls);
+        transactionResults.push({
+          status: vesuStatus,
+          calls: vesuCalls,
+          transactionMetadata: vesuTransactionMetadata
+        });
       }
       if (status && extended_amount.greaterThan(0)) {
-        const { calls: extendedCalls, status: extendedStatus } = await this.moveAssets(
+        const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
           {
             amount: extended_amount,
             from: Protocols.EXTENDED.name,
@@ -35297,30 +35263,35 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
         );
         status = extendedStatus;
         if (status) {
-          calls.push(...extendedCalls);
+          transactionResults.push({
+            status: extendedStatus,
+            calls: extendedCalls,
+            transactionMetadata: extendedTransactionMetadata
+          });
         } else {
           logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
-          return {
-            calls: [],
-            status
-          };
+          return [this.createTransactionResult([], status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
         }
       }
       const withdrawCall = await this.getBringLiquidityCall({
         amount
       });
       logger.info("withdraw call", withdrawCall);
-      calls.push(withdrawCall);
-      return {
-        calls,
-        status
-      };
+      transactionResults.push({
+        status,
+        calls: [withdrawCall],
+        transactionMetadata: {
+          protocolFrom: Protocols.VAULT.name,
+          protocolTo: Protocols.NONE.name,
+          transactionType: "WITHDRAWAL",
+          usdAmount: amount.toFixed(),
+          status: "PENDING"
+        }
+      });
+      return transactionResults;
     } catch (err) {
       logger.error(`error handling withdrawal: ${err}`);
-      return {
-        calls: [],
-        status: false
-      };
+      return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
     }
   }
   async getAUM() {
@@ -35367,6 +35338,36 @@ var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy exten
       splits: [realAUM, estimatedAUMDelta]
     };
   }
+  async processTransactionDataFromSDK(txnData) {
+    try {
+      const txnsToBeExecuted = txnData.filter((txn) => {
+        return txn.transactionMetadata.transactionType !== "NONE" && txn.transactionMetadata.protocolFrom !== "" && txn.transactionMetadata.protocolTo !== "";
+      });
+      const callsToBeExecutedFinal = txnsToBeExecuted.flatMap((txn) => txn.calls);
+      const txnMetadata = txnsToBeExecuted.map((txn) => txn.transactionMetadata);
+      return { callsToBeExecutedFinal, txnMetadata };
+    } catch (err) {
+      logger.error(`error processing transaction data from SDK: ${err}`);
+      return null;
+    }
+  }
+  async processTransactionMetadata(txnMetadata, extendedIntentFulfilled) {
+    try {
+      const txnMetadataNew = txnMetadata.map((txn) => {
+        const isExtendedProtocol = txn.protocolFrom === Protocols.EXTENDED.name || txn.protocolTo === Protocols.EXTENDED.name;
+        if (isExtendedProtocol) {
+          txn.status = extendedIntentFulfilled ? "COMPLETED" : "PENDING";
+        } else {
+          txn.status = "COMPLETED";
+        }
+        return txn;
+      });
+      return txnMetadataNew;
+    } catch (err) {
+      logger.error(`error processing transaction data from SDK: ${err}`);
+      return null;
+    }
+  }
 };
 function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
   vaultSettings.leafAdapters = [];
@@ -39800,6 +39801,7 @@ var deployer_default = Deployer;
   AssetOperationStatus,
   AssetOperationType,
   AutoCompounderSTRK,
+  AvnuAdapter,
   AvnuWrapper,
   BaseAdapter,
   BaseStrategy,
@@ -39883,6 +39885,7 @@ var deployer_default = Deployer;
   calculateExtendedLevergae,
   calculateVesUPositionSizeGivenExtended,
   calculateVesuLeverage,
+  calculateWBTCAmountToMaintainLTV,
   extensionMap,
   getAPIUsingHeadlessBrowser,
   getContractDetails,