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

package/dist/index.browser.global.js

@@ -28653,6 +28653,7 @@ ${r2}}` : "}", l2;
     AssetOperationStatus: () => AssetOperationStatus,
     AssetOperationType: () => AssetOperationType,
     AutoCompounderSTRK: () => AutoCompounderSTRK,
+    AvnuAdapter: () => AvnuAdapter,
     AvnuWrapper: () => AvnuWrapper,
     BaseAdapter: () => BaseAdapter,
     BaseStrategy: () => BaseStrategy,
@@ -28728,6 +28729,7 @@ ${r2}}` : "}", l2;
     calculateExtendedLevergae: () => calculateExtendedLevergae,
     calculateVesUPositionSizeGivenExtended: () => calculateVesUPositionSizeGivenExtended,
     calculateVesuLeverage: () => calculateVesuLeverage,
+    calculateWBTCAmountToMaintainLTV: () => calculateWBTCAmountToMaintainLTV,
     extensionMap: () => extensionMap,
     getContractDetails: () => getContractDetails,
     getFAQs: () => getFAQs,
@@ -92580,6 +92582,21 @@ spurious results.`);
       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 (err2) {
+      return { deltaCollateralAmountUnits: null };
+    }
+  };
   var calculateExposureDelta = (exposure_extended, exposure_vesu) => {
     const exposure_delta = new Web3Number(exposure_extended - exposure_vesu, 2);
     return exposure_delta.absoluteValue().toNumber();
@@ -93964,26 +93981,38 @@ spurious results.`);
       try {
         if (!this.client) {
           logger2.error("Client not initialized");
-          return false;
+          return {
+            status: false,
+            receivedTxnHash: false
+          };
         }
         if (amount.lessThanOrEqualTo(0)) {
           logger2.error(
             `Invalid withdrawal amount: ${amount.toNumber()}. Amount must be positive.`
           );
-          return false;
+          return {
+            status: false,
+            receivedTxnHash: false
+          };
         }
         if (amount.lessThanOrEqualTo(this.minimumExtendedMovementAmount)) {
           logger2.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) {
           logger2.error(
             "Cannot get holdings - unable to validate withdrawal amount"
           );
-          return false;
+          return {
+            status: false,
+            receivedTxnHash: false
+          };
         }
         const availableForWithdrawal = parseFloat(
           holdings.availableForWithdrawal
@@ -93992,14 +94021,20 @@ spurious results.`);
           logger2.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) {
           logger2.error(
             `Withdrawal amount ${withdrawalAmount} exceeds available balance ${availableForWithdrawal}`
           );
-          return false;
+          return {
+            status: false,
+            receivedTxnHash: false
+          };
         }
         logger2.info(
           `Withdrawing ${withdrawalAmount} from Extended. Available balance: ${availableForWithdrawal}`
@@ -94012,15 +94047,24 @@ spurious results.`);
             withdrawalRequest.data,
             "WITHDRAWAL" /* WITHDRAWAL */
           );
-          return withdrawalStatus;
+          return {
+            status: true,
+            receivedTxnHash: withdrawalStatus
+          };
         }
         logger2.error(
           `Withdrawal request failed with status: ${withdrawalRequest.status}`
         );
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       } catch (error2) {
         logger2.error(`Error creating Withdraw Call: ${error2}`);
-        return false;
+        return {
+          status: false,
+          receivedTxnHash: false
+        };
       }
     }
     async getHealthFactor() {
@@ -94506,6 +94550,334 @@ spurious results.`);
     }
   };
 
+  // src/strategies/universal-adapters/avnu-adapter.ts
+  var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
+    constructor(config3) {
+      super(config3, _AvnuAdapter.name, Protocols.AVNU);
+      this.config = config3;
+      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) {
+          logger2.error("error getting quote from avnu");
+          return [];
+        }
+        const getCalldata = await this.avnuWrapper.getSwapCallData(
+          quote,
+          vaultAllocator.address
+        );
+        const swapCallData = getCalldata[0];
+        const amount = uint256_exports.bnToUint256(quote.sellAmountInUsd * 10 ** 7);
+        return [
+          {
+            sanitizer: SIMPLE_SANITIZER,
+            call: {
+              contractAddress: fromToken.address,
+              selector: hash_exports.getSelectorFromName("approve"),
+              calldata: [
+                AVNU_EXCHANGE.toBigInt(),
+                toBigInt3(amount.low.toString()),
+                // amount low
+                toBigInt3(amount.high.toString())
+                // amount high
+              ]
+            }
+          },
+          {
+            sanitizer: SIMPLE_SANITIZER,
+            call: {
+              contractAddress: AVNU_EXCHANGE,
+              selector: hash_exports.getSelectorFromName("multi_route_swap"),
+              calldata: swapCallData
+            }
+          }
+        ];
+      } catch (error2) {
+        logger2.error(`Error getting Avnu quote: ${error2}`);
+        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) {
+          logger2.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 = uint256_exports.bnToUint256(params.amount.toWei());
+        return [
+          {
+            sanitizer: SIMPLE_SANITIZER,
+            call: {
+              contractAddress: fromToken.address,
+              selector: hash_exports.getSelectorFromName("approve"),
+              calldata: [
+                AVNU_EXCHANGE.toBigInt(),
+                toBigInt3(amount.low.toString()),
+                // amount low
+                toBigInt3(amount.high.toString())
+                // amount high
+              ]
+            }
+          },
+          {
+            sanitizer: SIMPLE_SANITIZER,
+            call: {
+              contractAddress: AVNU_EXCHANGE,
+              selector: hash_exports.getSelectorFromName("multi_route_swap"),
+              calldata: swapCallData
+            }
+          }
+        ];
+      } catch (error2) {
+        logger2.error(`Error getting Avnu quote: ${error2}`);
+        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 axios_default.get(this.config.baseUrl, { params });
+          if (response.data && response.data.length > 0) {
+            return response;
+          }
+          throw new Error("Empty response data");
+        } catch (err2) {
+          logger2.error(`Error fetching quote with retry: ${err2}`);
+          if (attempt === retries - 1) {
+            throw err2;
+          }
+          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) {
+            logger2.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) {
+          logger2.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) {
+          logger2.error("No quotes available for this swap, error in quotes avnu");
+          return null;
+        }
+        const dataObject = finalQuote.data[0];
+        return dataObject;
+      } catch (err2) {
+        logger2.error(`No quotes available for this swap: ${err2}`);
+        return null;
+      }
+    }
+    async getPriceOfToken(tokenAddress, retries = MAX_RETRIES) {
+      try {
+        const url = `https://starknet.impulse.avnu.fi/v1/tokens/${tokenAddress}/prices/line`;
+        const response = await axios_default.get(url);
+        const length = response.data.length;
+        return response.data[length - 1].value;
+      } catch (err2) {
+        if (retries > 0) {
+          await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
+          return this.getPriceOfToken(tokenAddress, retries - 1);
+        } else {
+          logger2.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";
@@ -97924,334 +98296,6 @@ spurious results.`);
     getStrategySettings("mRe7YIELD", "mRe7YIELD", hypermRe7YIELD, false, false)
   ];
 
-  // src/strategies/universal-adapters/avnu-adapter.ts
-  var AvnuAdapter = class _AvnuAdapter extends BaseAdapter {
-    constructor(config3) {
-      super(config3, _AvnuAdapter.name, Protocols.AVNU);
-      this.config = config3;
-      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) {
-          logger2.error("error getting quote from avnu");
-          return [];
-        }
-        const getCalldata = await this.avnuWrapper.getSwapCallData(
-          quote,
-          vaultAllocator.address
-        );
-        const swapCallData = getCalldata[0];
-        const amount = uint256_exports.bnToUint256(quote.sellAmountInUsd * 10 ** 7);
-        return [
-          {
-            sanitizer: SIMPLE_SANITIZER,
-            call: {
-              contractAddress: fromToken.address,
-              selector: hash_exports.getSelectorFromName("approve"),
-              calldata: [
-                AVNU_EXCHANGE.toBigInt(),
-                toBigInt3(amount.low.toString()),
-                // amount low
-                toBigInt3(amount.high.toString())
-                // amount high
-              ]
-            }
-          },
-          {
-            sanitizer: SIMPLE_SANITIZER,
-            call: {
-              contractAddress: AVNU_EXCHANGE,
-              selector: hash_exports.getSelectorFromName("multi_route_swap"),
-              calldata: swapCallData
-            }
-          }
-        ];
-      } catch (error2) {
-        logger2.error(`Error getting Avnu quote: ${error2}`);
-        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) {
-          logger2.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 = uint256_exports.bnToUint256(params.amount.toWei());
-        return [
-          {
-            sanitizer: SIMPLE_SANITIZER,
-            call: {
-              contractAddress: fromToken.address,
-              selector: hash_exports.getSelectorFromName("approve"),
-              calldata: [
-                AVNU_EXCHANGE.toBigInt(),
-                toBigInt3(amount.low.toString()),
-                // amount low
-                toBigInt3(amount.high.toString())
-                // amount high
-              ]
-            }
-          },
-          {
-            sanitizer: SIMPLE_SANITIZER,
-            call: {
-              contractAddress: AVNU_EXCHANGE,
-              selector: hash_exports.getSelectorFromName("multi_route_swap"),
-              calldata: swapCallData
-            }
-          }
-        ];
-      } catch (error2) {
-        logger2.error(`Error getting Avnu quote: ${error2}`);
-        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 axios_default.get(this.config.baseUrl, { params });
-          if (response.data && response.data.length > 0) {
-            return response;
-          }
-          throw new Error("Empty response data");
-        } catch (err2) {
-          logger2.error(`Error fetching quote with retry: ${err2}`);
-          if (attempt === retries - 1) {
-            throw err2;
-          }
-          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) {
-            logger2.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) {
-          logger2.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) {
-          logger2.error("No quotes available for this swap, error in quotes avnu");
-          return null;
-        }
-        const dataObject = finalQuote.data[0];
-        return dataObject;
-      } catch (err2) {
-        logger2.error(`No quotes available for this swap: ${err2}`);
-        return null;
-      }
-    }
-    async getPriceOfToken(tokenAddress, retries = MAX_RETRIES) {
-      try {
-        const url = `https://starknet.impulse.avnu.fi/v1/tokens/${tokenAddress}/prices/line`;
-        const response = await axios_default.get(url);
-        const length = response.data.length;
-        return response.data[length - 1].value;
-      } catch (err2) {
-        if (retries > 0) {
-          await new Promise((resolve) => setTimeout(resolve, MAX_DELAY));
-          return this.getPriceOfToken(tokenAddress, retries - 1);
-        } else {
-          logger2.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 = __toESM(require_jsx_runtime());
   var VesuExtendedMultiplierStrategy = class _VesuExtendedMultiplierStrategy extends SVKStrategy {
@@ -98368,10 +98412,16 @@ spurious results.`);
           proofGroups,
           await proofsInfo.callConstructor({ amount })
         );
-        return [approveCall, transferCall, call];
+        return {
+          calls: [approveCall, transferCall, call],
+          status: true
+        };
       } catch (err2) {
         logger2.error(`error moving assets to vault allocator: ${err2}`);
-        return [];
+        return {
+          calls: [],
+          status: false
+        };
       }
     }
     async shouldInvest() {
@@ -98620,9 +98670,10 @@ spurious results.`);
         const vesuAmountDifferenceAbs = vesuAmountDifference.abs();
         logger2.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,
@@ -98632,17 +98683,25 @@ spurious results.`);
               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 (err2) {
             logger2.error(`Failed moving assets to vault: ${err2}`);
+            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,
@@ -98651,18 +98710,26 @@ spurious results.`);
               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 (err2) {
-            logger2.error(`Failed moving assets to vault: ${err2}`);
+            logger2.error(`Failed moving assets to extended via vault allocator: ${err2}`);
+            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,
@@ -98672,18 +98739,22 @@ spurious results.`);
                 vesuAdapter
               );
               if (extendedStatus) {
-                calls.push(...extendedCalls);
+                transactionResults.push({
+                  status: extendedStatus,
+                  calls: extendedCalls,
+                  transactionMetadata: extendedTransactionMetadata
+                });
               } else {
                 logger2.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 (err2) {
               logger2.error(`Failed moving assets to extended: ${err2}`);
-              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,
@@ -98693,14 +98764,21 @@ spurious results.`);
                 vesuAdapter
               );
               if (extendedStatus) {
-                calls.push(...extendedCalls);
+                transactionResults.push({
+                  status: extendedStatus,
+                  calls: extendedCalls,
+                  transactionMetadata: {
+                    ...extendedTransactionMetadata,
+                    transactionType: "DEPOSIT"
+                  }
+                });
               } else {
                 logger2.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 (err2) {
               logger2.error(`Failed moving assets from extended to vault: ${err2}`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE")];
             }
           }
         }
@@ -98711,7 +98789,7 @@ spurious results.`);
             );
           } 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,
@@ -98722,20 +98800,46 @@ spurious results.`);
               );
               if (!vesuStatus) {
                 logger2.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 (err2) {
               logger2.error(`Failed moving assets to vault: ${err2}`);
-              return [];
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE")];
             }
           }
         }
-        return calls;
+        return transactionResults;
       } catch (err2) {
         logger2.error(`Failed moving assets to vesu: ${err2}`);
-        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 {
@@ -98743,10 +98847,7 @@ spurious results.`);
           logger2.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) {
@@ -98754,10 +98855,7 @@ spurious results.`);
             logger2.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) {
@@ -98765,19 +98863,13 @@ spurious results.`);
             logger2.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) {
           logger2.error(`avnu adapter not found: ${avnuAdapter}`);
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE");
         }
         logger2.info(`moveAssets params, ${JSON.stringify(params)}`);
         const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
@@ -98796,19 +98888,13 @@ spurious results.`);
             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) {
             logger2.error(`error getting extended holdings: ${extendedHoldings}`);
-            return {
-              calls: [],
-              status: false
-            };
+            return this.createTransactionResult([], false, params, "NONE");
           }
           const extendedHoldingAmount = new Web3Number(
             extendedHoldings.availableForWithdrawal,
@@ -98835,36 +98921,36 @@ spurious results.`);
             const updatedHoldings = await extendedAdapter.getExtendedDepositAmount();
             if (!updatedHoldings || new Web3Number(updatedHoldings.availableForWithdrawal, USDC_TOKEN_DECIMALS).lessThan(params.amount.abs())) {
               logger2.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);
+          logger2.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+          if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
             const extendedHoldings2 = await extendedAdapter.getExtendedDepositAmount();
             logger2.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) {
+            logger2.error("withdrawal from extended successful, but funds didn't get transferred to the wallet");
+            return this.createTransactionResult([], true, params, "WITHDRAWAL");
           } else {
             logger2.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) {
             logger2.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),
@@ -98885,18 +98971,12 @@ spurious results.`);
             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) {
             logger2.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(),
@@ -98927,127 +99007,21 @@ spurious results.`);
             await proofsInfoDeposit.callConstructor({ amount: params.amount })
           );
           calls.push(callDeposit);
-          return {
-            calls,
-            status: true
-          };
+          return this.createTransactionResult(calls, true, params, "DEPOSIT");
         }
-        return {
-          calls: [],
-          status: false
-        };
+        logger2.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
+        return this.createTransactionResult([], false, params, "NONE");
       } catch (err2) {
         logger2.error(`error moving assets: ${err2}`);
-        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) {
-          logger2.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) {
-          logger2.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) {
-          logger2.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) {
-          logger2.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
-        );
-        logger2.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)) {
-          logger2.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 (err2) {
         logger2.error(`error handling deposit: ${err2}`);
-        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) {
@@ -99092,12 +99066,8 @@ spurious results.`);
           const withdrawCall2 = await this.getBringLiquidityCall({
             amount: usdcBalanceVaultAllocator.amount
           });
-          logger2.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();
@@ -99106,11 +99076,9 @@ spurious results.`);
           logger2.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
@@ -99119,10 +99087,7 @@ spurious results.`);
         if (!extendedPositon) {
           status = false;
           logger2.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,
@@ -99135,14 +99100,11 @@ spurious results.`);
           logger2.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,
@@ -99152,10 +99114,14 @@ spurious results.`);
             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,
@@ -99166,30 +99132,35 @@ spurious results.`);
           );
           status = extendedStatus;
           if (status) {
-            calls.push(...extendedCalls);
+            transactionResults.push({
+              status: extendedStatus,
+              calls: extendedCalls,
+              transactionMetadata: extendedTransactionMetadata
+            });
           } else {
             logger2.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
         });
         logger2.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 (err2) {
         logger2.error(`error handling withdrawal: ${err2}`);
-        return {
-          calls: [],
-          status: false
-        };
+        return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount }, "NONE")];
       }
     }
     async getAUM() {
@@ -99236,6 +99207,36 @@ spurious results.`);
         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 (err2) {
+        logger2.error(`error processing transaction data from SDK: ${err2}`);
+        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 (err2) {
+        logger2.error(`error processing transaction data from SDK: ${err2}`);
+        return null;
+      }
+    }
   };
   function getLooperSettings2(lstSymbol, underlyingSymbol, vaultSettings, pool1, extendedBackendUrl, extendedApiKey, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing) {
     vaultSettings.leafAdapters = [];