@strkfarm/sdk 2.0.0-dev.2 → 2.0.0-dev.21

package/src/strategies/vesu-extended-strategy/vesu-extended-strategy.tsx

@@ -13,7 +13,8 @@ import { logger } from "@/utils";
 import { AUDIT_URL } from "../universal-lst-muliplier-strategy";
 import { getNoRiskTags } from "@/interfaces";
 import { _riskFactor } from "../universal-lst-muliplier-strategy";
-import { BUFFER_USDC_IN_WITHDRAWAL, EXTENDED_QTY_PRECISION, LIMIT_BALANCE, MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED, MINIMUM_EXTENDED_POSITION_SIZE, USDC_TOKEN_DECIMALS, WALLET_ADDRESS, WBTC_TOKEN_DECIMALS } from "./utils/constants";
+import { BUFFER_USDC_IN_WITHDRAWAL, LIMIT_BALANCE, LIMIT_BALANCE_VALUE, MINIMUM_EXTENDED_POSITION_SIZE, USDC_TOKEN_DECIMALS, WALLET_ADDRESS, WBTC_TOKEN_DECIMALS } from "./utils/constants";
+import { CycleType } from "./types/transaction-metadata";
 import { PricerBase } from "@/modules/pricerBase";
 import { ContractAddr, Web3Number } from "@/dataTypes";
 import { Global } from "@/global";
@@ -53,6 +54,8 @@ import {
 } from "./utils/helper";
 import { SingleTokenInfo } from "../base-strategy";
 import { Call } from "starknet";
+import { PositionTypeAvnuExtended } from "../universal-strategy";
+import { TransactionMetadata, TransactionResult } from "./types/transaction-metadata";
 
 
 export interface VesuExtendedStrategySettings
@@ -64,6 +67,7 @@ export interface VesuExtendedStrategySettings
   minHealthFactor: number;
   aumOracle: ContractAddr;
   minimumWBTCDifferenceForAvnuSwap: number;
+  walletAddress: string;
 }
 
 export class VesuExtendedMultiplierStrategy<
@@ -71,7 +75,6 @@ export class VesuExtendedMultiplierStrategy<
 >
   extends SVKStrategy<S>
   implements Operations {
-
   constructor(
     config: IConfig,
     pricer: PricerBase,
@@ -108,7 +111,7 @@ export class VesuExtendedMultiplierStrategy<
       debtPrice,
     };
   }
- 
+
   async getUnusedBalanceUSDCE(): Promise<SingleTokenInfo> {
     const usdceToken = Global.getDefaultTokens().find(
       (token) => token.symbol === "USDCe"
@@ -179,20 +182,40 @@ export class VesuExtendedMultiplierStrategy<
     return extendedAdapter.adapter as ExtendedAdapter;
   }
 
-  async moveAssetsToVaultAllocator(amount: Web3Number, extendedAdapter: ExtendedAdapter): Promise<Call[]> {
+  async moveAssetsToVaultAllocator(amount: Web3Number, extendedAdapter: ExtendedAdapter): Promise<{
+    calls: Call[],
+    status: boolean,
+  }> {
     try {
       const usdceToken = Global.getDefaultTokens().find(
         (token) => token.symbol === "USDCe"
       )!;
+      const walletBalance = await new ERC20(this.config).balanceOf(
+        usdceToken.address,
+        WALLET_ADDRESS,
+        usdceToken.decimals
+      );
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator walletBalance: ${walletBalance}`);
+      const amountToBeTransferred = amount.minimum(walletBalance);
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred: ${amountToBeTransferred.toNumber()}`);
+  
+      if (amountToBeTransferred.lessThan(0)) {
+        logger.error(`${VesuExtendedMultiplierStrategy.name}::moveAssetsToVaultAllocator amountToBeTransferred is less than 0: ${amountToBeTransferred.toNumber()}`);
+        return {
+          calls: [],
+          status: false,
+        };
+      }
+
       const approveCall = new ERC20(this.config).approve(
         usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
-        amount
+        amountToBeTransferred
       );
       const transferCall = new ERC20(this.config).transfer(
         usdceToken.address,
         this.metadata.additionalInfo.vaultAllocator,
-        amount
+        amountToBeTransferred
       );
       const proofsInfo = extendedAdapter.getProofsForFromLegacySwap(
         this.getMerkleTree()
@@ -200,12 +223,18 @@ export class VesuExtendedMultiplierStrategy<
       const proofGroups = proofsInfo.proofs;
       const call = this.getManageCall(
         proofGroups,
-        await proofsInfo.callConstructor({ amount: amount })
+        await proofsInfo.callConstructor({ amount: amountToBeTransferred })
       );
-      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,
+      };
     }
   }
 
@@ -219,11 +248,42 @@ export class VesuExtendedMultiplierStrategy<
     vesuLeverage: number;
   }> {
     try {
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest starting`);
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest adapters fetched: vesuAdapter=${!!vesuAdapter}, extendedAdapter=${!!extendedAdapter}, extendedAdapter.client=${!!extendedAdapter?.client}`);
+
+      if (!vesuAdapter) {
         logger.error(
-          `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
+          `Vesu adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!extendedAdapter) {
+        logger.error(
+          `Extended adapter not configured in metadata. This is a configuration issue, not a temporary failure.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!extendedAdapter.client) {
+        logger.error(
+          `Extended adapter client not initialized. This may be a temporary initialization failure - check network connectivity and API availability.`
         );
         return {
           shouldInvest: false,
@@ -235,12 +295,67 @@ export class VesuExtendedMultiplierStrategy<
           vesuLeverage: 0,
         };
       }
+
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest calling getUnusedBalance`);
       const balance = await this.getUnusedBalance();
+
+      if (!Number.isFinite(balance.usdValue) || balance.usdValue < 0) {
+        logger.error(
+          `Invalid balance.usdValue: ${balance.usdValue}. Expected a finite, non-negative number.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest balance: ${balance.usdValue}`);
       const usdcBalanceOnExtended = await extendedAdapter.getExtendedDepositAmount();
+
+      if (usdcBalanceOnExtended) {
+        const availableForWithdrawal = parseFloat(usdcBalanceOnExtended.availableForWithdrawal);
+        if (!Number.isFinite(availableForWithdrawal) || availableForWithdrawal < 0) {
+          logger.error(
+            `Invalid usdcBalanceOnExtended.availableForWithdrawal: ${usdcBalanceOnExtended.availableForWithdrawal}. Expected a finite, non-negative number.`
+          );
+          return {
+            shouldInvest: false,
+            vesuAmount: new Web3Number(0, 0),
+            extendedAmount: new Web3Number(0, 0),
+            extendedLeverage: 0,
+            collateralPrice: 0,
+            debtPrice: 0,
+            vesuLeverage: 0,
+          };
+        }
+      }
+
       /** The LIMIT_BALANCE is the bffer amount to keep in the investing Cycle */
-      const amountToInvest = balance.amount.plus(usdcBalanceOnExtended?.availableForWithdrawal ?? 0).minus(LIMIT_BALANCE);
+      const amountToInvest = new Web3Number(balance.usdValue, USDC_TOKEN_DECIMALS).plus(usdcBalanceOnExtended?.availableForWithdrawal ?? 0).multipliedBy(1 - LIMIT_BALANCE);
+
 
-      if (amountToInvest.lessThan(0)) {
+      const amountToInvestNumber = amountToInvest.toNumber();
+      if (!Number.isFinite(amountToInvestNumber)) {
+        logger.error(
+          `Invalid amountToInvest calculation result: ${amountToInvestNumber}. Calculation may have produced NaN or Infinity.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest amountToInvest: ${amountToInvestNumber}`);
+      if (amountToInvest.lessThan(LIMIT_BALANCE_VALUE)) {
         return {
           shouldInvest: false,
           vesuAmount: new Web3Number(0, 0),
@@ -272,6 +387,37 @@ export class VesuExtendedMultiplierStrategy<
         collateralPrice,
         debtPrice
       } = await this.getAssetPrices();
+
+
+      if (!Number.isFinite(collateralPrice.price) || collateralPrice.price <= 0) {
+        logger.error(
+          `Invalid collateralPrice: ${collateralPrice.price}. Expected a finite, positive number.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+      if (!Number.isFinite(debtPrice.price) || debtPrice.price <= 0) {
+        logger.error(
+          `Invalid debtPrice: ${debtPrice.price}. Expected a finite, positive number.`
+        );
+        return {
+          shouldInvest: false,
+          vesuAmount: new Web3Number(0, 0),
+          extendedAmount: new Web3Number(0, 0),
+          extendedLeverage: 0,
+          collateralPrice: 0,
+          debtPrice: 0,
+          vesuLeverage: 0,
+        };
+      }
+
       const { vesu_amount, extended_amount, extended_leverage, vesu_leverage } =
         await calculateAmountDistribution(
           amountToInvest.toNumber(),
@@ -301,6 +447,7 @@ export class VesuExtendedMultiplierStrategy<
           vesuLeverage: 0,
         };
       }
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldInvest vesu_amount: ${vesu_amount.toNumber()}, extended_amount: ${extended_amount.toNumber()}`);
       return {
         shouldInvest: true,
         vesuAmount: vesu_amount,
@@ -324,110 +471,258 @@ export class VesuExtendedMultiplierStrategy<
     }
   }
 
-  async shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<Call[]> {
+  async shouldMoveAssets(extendedAmount: Web3Number, vesuAmount: Web3Number): Promise<TransactionResult[]> {
     try {
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
-      let calls: Call[] = [];
       if (!vesuAdapter || !extendedAdapter || !extendedAdapter.client) {
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return calls;
+        return [];
+      }
+
+      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
+      if (!extendedHoldings) {
+        logger.error(`error getting extended holdings: ${extendedHoldings}`);
+        return [];
       }
-      if (extendedAmount.lessThan(0)) {
+      const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
+      const usdcAmountOnExtendedAvailableForWithdrawal = parseFloat(
+        extendedHoldings.availableForWithdrawal
+      );
+
+      logger.info(`${VesuExtendedMultiplierStrategy.name}::shouldMoveAssets calculating movements - Extended current: ${usdcAmountOnExtendedAvailableForWithdrawal}, Wallet: ${usdcAmountInWallet.toNumber()}, Target Extended: ${extendedAmount.toNumber()}, Target Vesu: ${vesuAmount.toNumber()}`);
+
+      let totalExtendedWithdrawal = new Web3Number(0, USDC_TOKEN_DECIMALS);
+      let totalExtendedDeposit = new Web3Number(0, USDC_TOKEN_DECIMALS);
+
+      if (extendedAmount.isNegative() && extendedAmount.abs().greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmount.abs());
+      }
+
+      // Calculate remaining Extended difference (target vs current)
+      // If extendedAmount was negative, we've already accounted for that withdrawal
+      // So we calculate based on what Extended will be after that withdrawal
+      const extendedTargetAmount = extendedAmount.abs(); // Use absolute value as target
+      let projectedExtendedBalance = usdcAmountOnExtendedAvailableForWithdrawal;
+
+      if (extendedAmount.isNegative()) {
+        projectedExtendedBalance = projectedExtendedBalance - extendedAmount.abs().toNumber();
+      }
+
+      const extendedAmountDifference = extendedTargetAmount.minus(projectedExtendedBalance);
+      const extendedAmountDifferenceAbs = extendedAmountDifference.abs();
+
+      // Track additional Extended movements
+      if (extendedAmountDifference.lessThan(0)) {
+        totalExtendedWithdrawal = totalExtendedWithdrawal.plus(extendedAmountDifferenceAbs);
+      } else if (extendedAmountDifference.greaterThan(0)) {
+        totalExtendedDeposit = totalExtendedDeposit.plus(extendedAmountDifference);
+      }
+
+      const vesuTargetAmount = vesuAmount.abs();
+      const projectedWalletBalance = usdcAmountInWallet
+        .plus(totalExtendedWithdrawal)
+        .minus(totalExtendedDeposit);
+
+      let vesuAmountDifference = vesuTargetAmount.minus(projectedWalletBalance);
+      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: Call[] = [];
+      let transactionResults: TransactionResult[] = [];
+
+      // Handle negative extendedAmount (initial withdrawal needed)
+      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,
               amount: extendedAmount.abs(),
+              cycleType: CycleType.INVESTMENT
             },
             extendedAdapter,
             vesuAdapter
           );
-          //If withdrawal succesfull, then do further
-          if(extendedStatus){
-          calls.push(...extendedCalls);
-          }else{
-            return [];
+          if (extendedStatus) {
+            transactionResults.push({
+              status: extendedStatus,
+              calls: extendedCalls,
+              transactionMetadata: {
+                ...extendedTransactionMetadata,
+                transactionType: "DEPOSIT",
+              },
+            })
+          } else {
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmount.abs() }, "NONE", CycleType.INVESTMENT)];
           }
         } 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", CycleType.INVESTMENT)];
         }
       }
 
-      if (vesuAmount.lessThan(0)) {
+      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,
               amount: vesuAmount.abs(),
+              cycleType: CycleType.INVESTMENT
             },
             extendedAdapter,
             vesuAdapter
           );
-          calls.push(...vesuCalls);
-          if(!vesuStatus){
-            return [];
+          if (!vesuStatus) {
+            return [this.createTransactionResult([], false, { from: Protocols.VESU.name, to: Protocols.EXTENDED.name, amount: vesuAmount.abs() }, "NONE", CycleType.INVESTMENT)];
           }
+          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", CycleType.INVESTMENT)];
         }
       }
 
-      const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-      if (!extendedHoldings) {
-        logger.error(`error getting extended holdings: ${extendedHoldings}`);
-        return calls;
-      }
-      const usdcAmountInWallet = (await this.getUnusedBalance()).amount;
-      const usdcAmountOnExtended = parseFloat(
-        extendedHoldings.availableForWithdrawal
-      );
-      if (extendedAmount.minus(usdcAmountOnExtended).greaterThan(0)) {
-        //move assets to extended
-        try {
-          const {calls: extendedCalls} = await this.moveAssets(
-            {
-              to: Protocols.EXTENDED.name,
-              from: Protocols.VAULT.name,
-              amount: extendedAmount.minus(usdcAmountOnExtended),
-            },
-            extendedAdapter,
-            vesuAdapter
-          );
-          calls.push(...extendedCalls);
-        } catch (err) {
-          logger.error(`Failed moving assets to extended: ${err}`);
+      // Handle Extended adjustments based on calculated difference
+      if (extendedAmountDifferenceAbs.greaterThan(extendedAdapter.minimumExtendedMovementAmount)) {
+        if (extendedAmountDifference.greaterThan(0)) {
+          try {
+            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+              {
+                to: Protocols.EXTENDED.name,
+                from: Protocols.VAULT.name,
+                amount: extendedAmountDifference,
+                cycleType: CycleType.INVESTMENT
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (extendedStatus) {
+              transactionResults.push({
+                status: extendedStatus,
+                calls: extendedCalls,
+                transactionMetadata: extendedTransactionMetadata
+              })
+            } else {
+              logger.error(`Failed to move assets to extended - operation returned false status`);
+              return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", CycleType.INVESTMENT)];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets to extended: ${err}`);
+            return [this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.EXTENDED.name, amount: extendedAmountDifference }, "NONE", CycleType.INVESTMENT)];
+          }
+        } else if (extendedAmountDifference.lessThan(0)) {
+          try {
+            const { calls: extendedCalls, status: extendedStatus, transactionMetadata: extendedTransactionMetadata } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: extendedAmountDifferenceAbs,
+                cycleType: CycleType.INVESTMENT
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (extendedStatus) {
+              transactionResults.push({
+                status: extendedStatus,
+                calls: extendedCalls,
+                transactionMetadata: {
+                  ...extendedTransactionMetadata,
+                  transactionType: "DEPOSIT",
+                }
+              })
+            } else {
+              logger.error(`Failed to withdraw from extended - operation returned false status`);
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", CycleType.INVESTMENT)];
+            }
+          } catch (err) {
+            logger.error(`Failed moving assets from extended to vault: ${err}`);
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: extendedAmountDifferenceAbs }, "NONE", CycleType.INVESTMENT)];
+          }
         }
       }
-      if (vesuAmount.minus(usdcAmountInWallet).greaterThan(0)) {
-        //move assets to vesu
-        try {
-          const {calls: vesuCalls, status: vesuStatus} = await this.moveAssets(
-            {
-              to: Protocols.VAULT.name,
-              from: Protocols.EXTENDED.name,
-              amount: vesuAmount.minus(usdcAmountInWallet),
-            },
-            extendedAdapter,
-            vesuAdapter
+
+      // Handle Vesu adjustments based on calculated difference (already adjusted for Extended movements)
+      if (vesuAmountDifferenceAbs.greaterThan(vesuAdapter.minimumVesuMovementAmount)) {
+        if (vesuAmountDifference.lessThanOrEqualTo(0)) {
+          logger.warn(
+            `Vesu amount difference is negative or zero: ${vesuAmountDifference.toNumber()}. Skipping operation.`
           );
-          if(!vesuStatus){
-            return [];
+        } else {
+          // Move assets from Extended to Vault (which will then go to Vesu)
+          try {
+            const { calls: vesuCalls, status: vesuStatus, transactionMetadata: vesuTransactionMetadata } = await this.moveAssets(
+              {
+                to: Protocols.VAULT.name,
+                from: Protocols.EXTENDED.name,
+                amount: vesuAmountDifference,
+                cycleType: CycleType.INVESTMENT
+              },
+              extendedAdapter,
+              vesuAdapter
+            );
+            if (!vesuStatus) {
+              logger.error(`Failed to move assets to vesu - operation returned false status`);
+              return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", CycleType.INVESTMENT)];
+            }
+            transactionResults.push({
+              status: vesuStatus,
+              calls: vesuCalls,
+              transactionMetadata: {
+                ...vesuTransactionMetadata,
+                transactionType: "DEPOSIT",
+              }
+            })
+          } catch (err) {
+            logger.error(`Failed moving assets to vault: ${err}`);
+            return [this.createTransactionResult([], false, { from: Protocols.EXTENDED.name, to: Protocols.VAULT.name, amount: vesuAmountDifference }, "NONE", CycleType.INVESTMENT)];
           }
-          calls.push(...vesuCalls);
-        } catch (err) {
-          logger.error(`Failed moving assets to vault: ${err}`);
         }
       }
-      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", CycleType.INVESTMENT)];
+    }
+  }
+
+  /**
+   * Helper method to create transaction result with metadata
+   */
+  private createTransactionResult(
+    calls: Call[],
+    status: boolean,
+    params: { from: string; to: string; amount: Web3Number },
+    transactionType: 'DEPOSIT' | 'WITHDRAWAL' | 'NONE',
+    cycleType: CycleType
+  ): TransactionResult {
+    if (status) {
+      return {
+        calls,
+        status: status,
+        transactionMetadata: {
+          protocolFrom: params.from,
+          protocolTo: params.to,
+          transactionType: transactionType,
+          usdAmount: params.amount.abs().toFixed(),
+          status: 'PENDING',
+          cycleType: cycleType
+        }
+      };
     }
+    return { calls: [], status: false, transactionMetadata: { protocolFrom: '', protocolTo: '', transactionType: 'DEPOSIT', usdAmount: '0', status: 'FAILED', cycleType: cycleType } };
   }
 
   async moveAssets(
@@ -435,21 +730,43 @@ export class VesuExtendedMultiplierStrategy<
       amount: Web3Number;
       from: string;
       to: string;
+      cycleType: CycleType;
     },
     extendedAdapter: ExtendedAdapter,
-    vesuAdapter: VesuMultiplyAdapter
-  ): Promise<{
-    calls: Call[];
-    status: boolean;
-  }> {
+    vesuAdapter: VesuMultiplyAdapter,
+  ): Promise<TransactionResult> {
     try {
+      // Validate amount is positive before starting operations
+      if (params.amount.lessThanOrEqualTo(0)) {
+        logger.error(
+          `Invalid amount for moveAssets: ${params.amount.toNumber()}. Amount must be positive.`
+        );
+        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+      }
+
+      // Check minimum movement amounts before starting operations
+      const amountAbs = params.amount.abs();
+      if (params.from === Protocols.EXTENDED.name || params.to === Protocols.EXTENDED.name) {
+        if (amountAbs.lessThanOrEqualTo(extendedAdapter.minimumExtendedMovementAmount)) {
+          logger.warn(
+            `Amount ${amountAbs.toNumber()} is below minimum Extended movement amount ${extendedAdapter.minimumExtendedMovementAmount}. Skipping operation.`
+          );
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        }
+      }
+      if (params.from === Protocols.VESU.name || params.to === Protocols.VESU.name) {
+        if (amountAbs.lessThanOrEqualTo(vesuAdapter.minimumVesuMovementAmount)) {
+          logger.warn(
+            `Amount ${amountAbs.toNumber()} is below minimum Vesu movement amount ${vesuAdapter.minimumVesuMovementAmount}. Skipping operation.`
+          );
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        }
+      }
+
       const avnuAdapter = await this.getAvnuAdapter();
       if (!avnuAdapter) {
         logger.error(`avnu adapter not found: ${avnuAdapter}`);
-        return {
-          calls: [],
-          status: false
-        };
+        return this.createTransactionResult([], false, params, "NONE", params.cycleType);
       }
       logger.info(`moveAssets params, ${JSON.stringify(params)}`);
       const collateralToken = vesuAdapter.config.supportedPositions[0].asset;
@@ -469,67 +786,84 @@ export class VesuExtendedMultiplierStrategy<
           await proofsInfo.callConstructor({ amount: params.amount })
         );
         calls.push(call);
-        return {
-          calls: [call],
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
       } 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", params.cycleType);
         }
         const extendedHoldingAmount = new Web3Number(
           extendedHoldings.availableForWithdrawal,
           USDC_TOKEN_DECIMALS
         );
-      
-        const leftAmountAfterWithdrawalAmountInAccount = params.amount.minus(extendedHoldingAmount);
-        const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(collateralPrice.price);
-        const openLongPosition = await extendedAdapter.createOrder(
-          extendedLeverage.toString(),
-          btcAmount.toNumber(),
-          OrderSide.BUY
-        )
-        if (!openLongPosition) {
-          logger.error(`error opening long position: ${openLongPosition}`);
-          return {
-            calls: [],
-            status: false
-          };
+        logger.info(`${VesuExtendedMultiplierStrategy.name}::moveAssets extendedHoldingAmount: ${extendedHoldingAmount.toNumber()}`);
+        if (params.amount.abs().greaterThan(extendedHoldingAmount)) {
+          const leftAmountAfterWithdrawalAmountInAccount = params.amount.abs().minus(extendedHoldingAmount);
+          logger.info(`${VesuExtendedMultiplierStrategy.name}::moveAssets leftAmountAfterWithdrawalAmountInAccount: ${leftAmountAfterWithdrawalAmountInAccount.toNumber()}`);
+          const btcAmount = leftAmountAfterWithdrawalAmountInAccount.dividedBy(collateralPrice.price);
+          const openLongPosition = btcAmount.multipliedBy(3).greaterThan(MINIMUM_EXTENDED_POSITION_SIZE) ? await extendedAdapter.createOrder(
+            extendedLeverage.toString(),
+            btcAmount.toNumber(),
+            OrderSide.BUY
+          ) : await extendedAdapter.createOrder(
+            extendedLeverage.toString(),
+            0.000034, // just in case amount falls short then we need to create a withdrawal
+            OrderSide.BUY
+          )
+          if (!openLongPosition) {
+            logger.error(`error opening long position: ${openLongPosition}`);
+          }
+          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 this.createTransactionResult([], false, params, "NONE", params.cycleType);
+          }
         }
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        const withdrawalFromExtended =
+        const {
+          status: withdrawalFromExtendedStatus,
+          receivedTxnHash: withdrawalFromExtendedTxnHash,
+        } =
           await extendedAdapter.withdrawFromExtended(params.amount);
-        if (withdrawalFromExtended) {
+        /**
+         * This logic needs fixing
+         */
+        logger.info(`withdrawalFromExtendedStatus: ${withdrawalFromExtendedStatus}, withdrawalFromExtendedTxnHash: ${withdrawalFromExtendedTxnHash}`);
+        if (withdrawalFromExtendedStatus && withdrawalFromExtendedTxnHash) {
           /**
           * We need to move assets from my wallet back to vault contract
           */
           const extendedHoldings = await extendedAdapter.getExtendedDepositAmount();
-          logger.info(`extendedHoldings after withdrawal ${extendedHoldings}`);
-          await new Promise(resolve => setTimeout(resolve, 10000));
-          const calls = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
-          if (calls.length > 0) {
-            return {
-              calls: calls,
-              status: true
-            };
+          logger.info(`extendedHoldings after withdrawal ${extendedHoldings?.availableForWithdrawal}`);
+          await new Promise(resolve => setTimeout(resolve, 5000));
+          const { calls, status } = await this.moveAssetsToVaultAllocator(params.amount, extendedAdapter);
+          if (calls.length > 0 && status) {
+            return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
+          } else {
+            /**
+             * This is a fallback scenario, where the funds were withdrawn from extended, but didn't get transferred to the wallet
+             * We need to return a successful transaction result, but with no calls
+             * Db update will be handled by the risk engine for this specific case
+             */
+            return this.createTransactionResult([], true, params, "WITHDRAWAL", params.cycleType);
           }
+        } 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", params.cycleType);
         } else {
           logger.error("withdrawal from extended failed");
-          return {
-            calls: [],
-            status: false
-          };
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
         }
       } else if (params.to === Protocols.VAULT.name && params.from === Protocols.VESU.name) {
+        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, PositionTypeAvnuExtended.CLOSE);
+        if (!isPriceDifferenceBetweenAvnuAndExtended) {
+          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        }
         //withdraw from vesu 
         const vesuAmountInBTC = new Web3Number(
-          params.amount.dividedBy(collateralPrice.price).toNumber(),
+          params.amount.dividedBy(collateralPrice.price).toFixed(WBTC_TOKEN_DECIMALS),
           collateralToken.decimals
         );
         const proofsInfo = vesuAdapter.getProofs(false, this.getMerkleTree());
@@ -547,11 +881,13 @@ export class VesuExtendedMultiplierStrategy<
           await swapProofsInfo.callConstructor({ amount: vesuAmountInBTC })
         );
         calls.push(swapCall);
-        return {
-          calls: calls,
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "WITHDRAWAL", params.cycleType);
       } else if (params.to === Protocols.EXTENDED.name && params.from === Protocols.VESU.name) {
+        const isPriceDifferenceBetweenAvnuAndExtended = await this.checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter, vesuAdapter, avnuAdapter, PositionTypeAvnuExtended.CLOSE);
+        if (!isPriceDifferenceBetweenAvnuAndExtended) {
+          logger.warn(`price difference between avnu and extended doesn't fit the range for close position, ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+          return this.createTransactionResult([], false, params, "NONE", params.cycleType);
+        }
         const vesuAmountInBTC = new Web3Number(
           params.amount.dividedBy(collateralPrice.price).toNumber(),
           collateralToken.decimals
@@ -582,163 +918,77 @@ export class VesuExtendedMultiplierStrategy<
           await proofsInfoDeposit.callConstructor({ amount: params.amount })
         );
         calls.push(callDeposit);
-        return {
-          calls: calls,
-          status: true
-        };
+        return this.createTransactionResult(calls, true, params, "DEPOSIT", params.cycleType);
       }
-      return {
-        calls: [],
-        status: false
-      };
+      logger.error(`Unsupported assets movement: ${params.from} to ${params.to}`);
+      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
     } catch (err) {
       logger.error(`error moving assets: ${err}`);
-      return {
-        calls: [],
-        status: false
-      };
+      return this.createTransactionResult([], false, params, "NONE", params.cycleType);
     }
   }
 
-  async handleDeposit(): Promise<{
-    extendedAmountInBTC: Web3Number,
-    calls: Call[]
-  }> {
+  async handleDeposit(): Promise<TransactionResult> {
     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);
-      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 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,
-        collateralTokenAmount,
-        collateralPrice.price
-      );
-     logger.info(`vesuAmountInBTC ${vesuAmountInBTC}, extendedAmountInBTC ${extendedAmountInBTC}`);
-     
-      let calls: Call[] = [];
-      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)) {
-          logger.info(`WBTC amount in vault allocator is less than vesu amount required in WBTC thus swapping, wbtcAmountInVaultAllocator: ${wbtcAmountInVaultAllocator}, vesuAmountInBTC: ${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(),
-        OrderSide.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: extendedAmountInBTC,
-        calls: calls,
-      };
+      /**
+       * Just a demo function, not used in the risk engine
+       */
+      return this.createTransactionResult([], false, { from: Protocols.VAULT.name, to: Protocols.VAULT.name, amount: new Web3Number(0, 0) }, "NONE", CycleType.INVESTMENT);
     } 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", CycleType.INVESTMENT);
     }
   }
 
-  async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter, avnuAdapter: AvnuAdapter): Promise<boolean> {
+
+  /**
+   * Check if the price difference between avnu and extended is within the acceptable range to enhance the position size or close the position
+   * @param extendedAdapter - the extended adapter
+   * @param vesuAdapter - the vesu adapter
+   * @param avnuAdapter - the avnu adapter
+   * @param positionType - the position type (open or close)
+   * @returns true if the price difference is within the acceptable range, false otherwise
+   */
+  async checkPriceDifferenceBetweenAvnuAndExtended(extendedAdapter: ExtendedAdapter, vesuAdapter: VesuMultiplyAdapter, avnuAdapter: AvnuAdapter, positionType: PositionTypeAvnuExtended): Promise<boolean> {
     const {
       ask, bid
     } = await extendedAdapter.fetchOrderBookBTCUSDC();
     const price = ask.plus(bid).dividedBy(2);
     const btcToken = vesuAdapter.config.supportedPositions[0].asset;
     const btcPriceAvnu = await avnuAdapter.getPriceOfToken(btcToken.address.toString());
+
     if (!btcPriceAvnu) {
       logger.error(`error getting btc price avnu: ${btcPriceAvnu}`);
       return false;
     }
-    const priceDifference = price.minus(btcPriceAvnu).toNumber();
-    if (priceDifference < MAX_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED && priceDifference > MIN_PRICE_DIFFERENCE_BETWEEN_AVNU_AND_EXTENDED) {
-      return true;
+    logger.info(`price: ${price}`);
+    logger.info(`btcPriceAvnu: ${btcPriceAvnu}`);
+    const priceDifference = new Web3Number(price.minus(btcPriceAvnu).toFixed(2), 0);
+    logger.info(`priceDifference: ${priceDifference}`);
+    if (priceDifference.isNegative()) {
+      return false;
+    }
+    if (positionType === PositionTypeAvnuExtended.OPEN) {
+      logger.info(`price difference between avnu and extended for open position: ${priceDifference.toNumber()}, minimumExtendedPriceDifferenceForSwapOpen: ${avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen}`);
+      const result = priceDifference.greaterThanOrEqualTo(avnuAdapter.config.minimumExtendedPriceDifferenceForSwapOpen); // 500 for now
+      logger.info(`result: ${result}`);
+      return result;
+    } else {
+      logger.info(`price difference between avnu and extended for close position: ${priceDifference.toNumber()}, maximumExtendedPriceDifferenceForSwapClosing: ${avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing}`);
+      const result = priceDifference.lessThanOrEqualTo(avnuAdapter.config.maximumExtendedPriceDifferenceForSwapClosing); // 1000 for now
+      logger.info(`result: ${result}`);
+      return result;
     }
-    logger.error(`price difference between avnu and extended doesn't fit the range, priceDifference: ${priceDifference}`);
-    return false;
   }
 
-  async handleWithdraw(amount: Web3Number): Promise<{calls: Call[], status: boolean}> {
+  /**
+   * Handle the withdrawal of assets from the vault
+   * @param amount - the amount to withdraw in USDC
+   * @returns the calls to be executed and the status of the calls generated along with the metadata for the calls
+   */
+  async handleWithdraw(amount: Web3Number): Promise<TransactionResult[]> {
     try {
-      const usdcBalanceVaultAllocator = await this.getUnusedBalance()
+      const usdcBalanceVaultAllocator = await this.getUnusedBalance();
       const usdcBalanceDifference = amount.plus(BUFFER_USDC_IN_WITHDRAWAL).minus(usdcBalanceVaultAllocator.usdValue);
       logger.info(`usdcBalanceDifference, ${usdcBalanceDifference.toNumber()}`);
       let calls: Call[] = [];
@@ -747,12 +997,8 @@ export class VesuExtendedMultiplierStrategy<
         const withdrawCall = await this.getBringLiquidityCall({
           amount: usdcBalanceVaultAllocator.amount
         })
-        logger.info("withdraw call", withdrawCall);
         calls.push(withdrawCall);
-        return {
-          calls:calls,
-          status:true
-        };
+        return [this.createTransactionResult(calls, true, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "WITHDRAWAL", CycleType.WITHDRAWAL)];
       }
       const vesuAdapter = await this.getVesuAdapter();
       const extendedAdapter = await this.getExtendedAdapter();
@@ -761,24 +1007,19 @@ export class VesuExtendedMultiplierStrategy<
         logger.error(
           `vesu or extended adapter not found: vesuAdapter=${vesuAdapter}, extendedAdapter=${extendedAdapter}`
         );
-        return {
-          calls:calls,
-          status:status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
       }
+      let transactionResults: TransactionResult[] = [];
       const { collateralTokenAmount } =
         await vesuAdapter.vesuAdapter.getAssetPrices();
       const {
         collateralPrice
       } = await this.getAssetPrices();
       const extendedPositon = await extendedAdapter.getAllOpenPositions();
-      if(!extendedPositon) {
+      if (!extendedPositon) {
         status = false;
         logger.error("error getting extended position", extendedPositon);
-        return {
-          calls:calls,
-          status:status
-        }
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
       }
       const amountDistributionForWithdrawal =
         await calculateAmountDistributionForWithdrawal(
@@ -792,62 +1033,71 @@ export class VesuExtendedMultiplierStrategy<
         logger.error(
           `error calculating amount distribution for withdrawal: ${amountDistributionForWithdrawal}`
         );
-        return {
-          calls:calls,
-          status:status
-        };
+        return [this.createTransactionResult(calls, status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
       }
       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,
             to: Protocols.VAULT.name,
+            cycleType: CycleType.WITHDRAWAL
           },
           extendedAdapter,
           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,
             to: Protocols.VAULT.name,
+            cycleType: CycleType.WITHDRAWAL
           },
           extendedAdapter,
           vesuAdapter
         );
         status = extendedStatus;
-        if(status) {
-          calls.push(...extendedCalls);
-        }else{
+        if (status) {
+          transactionResults.push({
+            status: extendedStatus,
+            calls: extendedCalls,
+            transactionMetadata: extendedTransactionMetadata
+          })
+        } else {
           logger.error("error moving assets to vault: extendedStatus: ${extendedStatus}");
-          return {
-            calls: [],
-            status: status
-          };
+          return [this.createTransactionResult([], status, { from: Protocols.VAULT.name, to: Protocols.NONE.name, amount: amount }, "NONE", CycleType.WITHDRAWAL)];
         }
       }
       const withdrawCall = await this.getBringLiquidityCall({
         amount: amount
       })
       logger.info("withdraw call", withdrawCall);
-      calls.push(withdrawCall);
-      return {
-        calls: calls,
-        status: status
-      };
+      transactionResults.push({
+        status: status,
+        calls: [withdrawCall],
+        transactionMetadata: {
+          protocolFrom: Protocols.VAULT.name,
+          protocolTo: Protocols.NONE.name,
+          transactionType: "WITHDRAWAL",
+          usdAmount: amount.toFixed(),
+          status: 'PENDING',
+          cycleType: CycleType.WITHDRAWAL
+        }
+      })
+      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: amount }, "NONE", CycleType.WITHDRAWAL)];
     }
   }
 
@@ -896,6 +1146,187 @@ export class VesuExtendedMultiplierStrategy<
     };
   }
 
+  async processTransactionDataFromSDK(txnData: TransactionResult<any>[]): Promise<{ callsToBeExecutedFinal: Call[], txnMetadata: TransactionMetadata[] } | null> {
+    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: TransactionMetadata[], extendedIntentFulfilled: boolean): Promise<TransactionMetadata[] | null> {
+    try {
+      const txnMetadataNew = txnMetadata.map(txn => {
+        const isExtendedProtocol = txn.protocolFrom === Protocols.EXTENDED.name || txn.protocolTo === Protocols.EXTENDED.name;
+        // Only update status for extended protocol transactions since thsoe only cause delays
+        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;
+    }
+  }
+
+  async getMaxBorrowableAmount(): Promise<Web3Number> {
+    const vesuAdapter = await this.getVesuAdapter();
+    const extendedAdapter = await this.getExtendedAdapter();
+    if (!vesuAdapter || !extendedAdapter) {
+      return new Web3Number(0, 0);
+    }
+    const extendedFundingRate = new Web3Number((await extendedAdapter.getNetAPY()).toFixed(4), 0);
+    const extendedPositions = await extendedAdapter.getAllOpenPositions();
+    if (!extendedPositions || extendedPositions.length === 0) {
+      logger.info(`no extended positions found`);
+      return new Web3Number(0, 0);
+    }
+    const extendePositionSizeUSD = new Web3Number(extendedPositions[0].value || 0, 0);
+    const vesuPositions = await vesuAdapter.getPositions();
+    const vesuSupplyApy = vesuPositions[0].apy.apy;
+    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS)
+     const num1 = extendePositionSizeUSD.multipliedBy(extendedFundingRate);
+    const num2 = vesuCollateralSizeUSD.multipliedBy(vesuSupplyApy);
+    const num3 = vesuDebtSizeUSD.abs()
+    const maxBorrowApy = num1.plus(num2).minus(0.1).dividedBy(num3);
+    const vesuMaxBorrowableAmount = await vesuAdapter.vesuAdapter.getMaxBorrowableByInterestRate(this.config, vesuAdapter.config.debt, maxBorrowApy.toNumber());
+    return new Web3Number(vesuMaxBorrowableAmount.toFixed(USDC_TOKEN_DECIMALS), USDC_TOKEN_DECIMALS);
+  }
+
+  async getVesuHealthFactors(): Promise<number[]> {
+    const vesuAdapter = await this.getVesuAdapter();
+    const extendedAdapter = await this.getExtendedAdapter();
+    if (!vesuAdapter || !extendedAdapter) {
+      return [0, 0];
+    }
+    const vesuPositions = await vesuAdapter.getPositions();
+    const vesuCollateralSizeUSD = new Web3Number(vesuPositions[0].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+    const vesuDebtSizeUSD = new Web3Number(vesuPositions[1].usdValue.toFixed(USDC_TOKEN_DECIMALS), 0);
+    const actualLtv = vesuDebtSizeUSD.dividedBy(vesuCollateralSizeUSD).abs();
+    logger.info(`actualLtv: ${actualLtv.toNumber()}`);
+    const maxLtv = new Web3Number(await vesuAdapter.vesuAdapter.getLTVConfig(this.config), 4);
+    const healthFactor = new Web3Number(maxLtv.dividedBy(actualLtv).toFixed(4), 4);
+    logger.info(`healthFactor: ${healthFactor.toNumber()}`);
+    const extendedBalance = await extendedAdapter.getExtendedDepositAmount();
+    if (!extendedBalance) {
+      return [0, 0];
+    }
+    const extendedLeverage = new Web3Number((Number(extendedBalance.marginRatio) * 100).toFixed(4), 4);
+    logger.info(`extendedLeverage: ${extendedLeverage.toNumber()}`);
+    return [healthFactor.toNumber(), extendedLeverage.toNumber()];
+  }
+
+  async netAPY(): Promise<{ net: number; splits: { apy: number; id: string; }[]; }> {
+    const allPositions: PositionInfo[] = [];
+    for (let adapter of this.metadata.additionalInfo.adapters) {
+        if(adapter.adapter.name !== ExtendedAdapter.name){
+          let positions = await adapter.adapter.getPositions();
+          if(positions.length > 0){
+            allPositions.push(...positions);
+          }
+        }
+      }
+    const extendedAdapter =await this.getExtendedAdapter()
+    if(!extendedAdapter){
+      return {
+        net: 0,
+        splits: []
+      }
+    }
+    let vesuPositions = allPositions.filter((item) => item.protocol === Protocols.VESU);
+    vesuPositions.map((item) =>{
+      item.apy.apy = item.apy.apy * 0.1;
+    })
+    const extendedPositions = await extendedAdapter.getAllOpenPositions();
+    const usdcToken = Global.getDefaultTokens().find(token => token.symbol === "USDC");
+    if(!extendedPositions || !usdcToken){
+      return {
+        net: 0,
+        splits: []
+      }
+    }
+    const extendedPosition = extendedPositions[0] || 0;
+    const extendedEquity = (await extendedAdapter.getExtendedDepositAmount())?.equity || 0;
+    const extendedApy = await extendedAdapter.getNetAPY();
+    const totalHoldingsUSDValue = allPositions.reduce((acc, curr) => acc + curr.usdValue, 0) + Number(extendedEquity);
+    console.log(totalHoldingsUSDValue)
+    const extendedPositionSizeMultipliedByApy = Number(extendedPosition.value) * extendedApy;
+    let weightedAPYs = allPositions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) + extendedPositionSizeMultipliedByApy;
+    console.log(weightedAPYs)
+    const netAPY = weightedAPYs / totalHoldingsUSDValue;
+    console.log(netAPY)
+    allPositions.push({
+      tokenInfo: usdcToken,
+      amount: new Web3Number(extendedPosition.size, 0),
+      usdValue: Number(extendedEquity),
+      apy: { apy: extendedApy, type: APYType.BASE },
+      remarks: AUMTypes.FINALISED,
+      protocol: Protocols.EXTENDED 
+    })
+    return {
+      net: netAPY,
+      splits: allPositions.map(p => ({apy: p.apy.apy, id: p.remarks ?? ''}))
+    };
+  }
+
+  async getWalletHoldings(): Promise<{
+    tokenInfo: TokenInfo,
+    amount: Web3Number,
+    usdValue: number
+  }[]> {
+    const usdceToken = Global.getDefaultTokens().find(token => token.symbol === "USDCe");
+    const wbtcToken = Global.getDefaultTokens().find(token => token.symbol === "WBTC");
+    const usdcToken = Global.getDefaultTokens().find(token => token.symbol === "USDC");
+    if (!usdceToken || !wbtcToken || !usdcToken) {
+      return [];
+    }
+    const walletAddress = this.metadata.additionalInfo.walletAddress;
+    const usdceWalletBalance = await new ERC20(this.config).balanceOf(
+      usdceToken.address,
+      walletAddress,
+      usdceToken.decimals
+    );
+    const usdcWalletBalance = await new ERC20(this.config).balanceOf(
+      usdcToken.address,
+      walletAddress,
+      usdcToken.decimals
+    );
+    const wbtcWalletBalance = await new ERC20(this.config).balanceOf(
+      wbtcToken.address,
+      walletAddress,
+      wbtcToken.decimals
+    );
+    const price = await this.pricer.getPrice(usdceToken.symbol);
+    const wbtcPrice = await this.pricer.getPrice(wbtcToken.symbol);
+    const usdceUsdValue = Number(usdceWalletBalance.toFixed(usdceToken.decimals)) * price.price;
+    const usdcUsdValue = Number(usdcWalletBalance.toFixed(usdcToken.decimals)) * price.price;
+    const wbtcUsdValue = Number(wbtcWalletBalance.toFixed(wbtcToken.decimals)) * wbtcPrice.price;
+    return [{
+      tokenInfo: usdceToken,
+      amount: usdceWalletBalance,
+      usdValue: usdceUsdValue
+    },
+    {
+      tokenInfo: usdcToken,
+      amount: usdcWalletBalance,
+      usdValue: usdcUsdValue
+    }, {
+      tokenInfo: wbtcToken,
+      amount: wbtcWalletBalance,
+      usdValue: wbtcUsdValue
+    }];
+  }
 }
 
 function getLooperSettings(
@@ -903,9 +1334,14 @@ function getLooperSettings(
   underlyingSymbol: string,
   vaultSettings: VesuExtendedStrategySettings,
   pool1: ContractAddr,
-  extendedBackendUrl: string,
-  extendedApiKey: string,
+  extendedBackendReadUrl: string,
+  extendedBackendWriteUrl: string,
   vaultIdExtended: number,
+  minimumExtendedMovementAmount: number,
+  minimumVesuMovementAmount: number,
+  minimumExtendedRetriesDelayForOrderStatus: number,
+  minimumExtendedPriceDifferenceForSwapOpen: number,
+  maximumExtendedPriceDifferenceForSwapClosing: number,
 ) {
   vaultSettings.leafAdapters = [];
 
@@ -934,6 +1370,8 @@ function getLooperSettings(
     avnuContract: AVNU_MIDDLEWARE,
     slippage: 0.01,
     baseUrl: AVNU_QUOTE_URL,
+    minimumExtendedPriceDifferenceForSwapOpen: minimumExtendedPriceDifferenceForSwapOpen,
+    maximumExtendedPriceDifferenceForSwapClosing: maximumExtendedPriceDifferenceForSwapClosing,
   });
 
   const extendedAdapter = new ExtendedAdapter({
@@ -943,14 +1381,16 @@ function getLooperSettings(
     ],
     vaultIdExtended: vaultIdExtended,
     extendedContract: EXTENDED_CONTRACT,
-    extendedBackendUrl: extendedBackendUrl,
-    extendedApiKey: extendedApiKey,
+    extendedBackendWriteUrl: extendedBackendWriteUrl,
+    extendedBackendReadUrl: extendedBackendReadUrl,
     extendedTimeout: 30000,
     extendedRetries: 3,
     extendedBaseUrl: "https://api.starknet.extended.exchange",
     extendedMarketName: "BTC-USD",
     extendedPrecision: 5,
     avnuAdapter: avnuAdapter,
+    retryDelayForOrderStatus: minimumExtendedRetriesDelayForOrderStatus ?? 3000,
+    minimumExtendedMovementAmount: minimumExtendedMovementAmount ?? 5, //5 usdcs
   });
 
   const vesuMultiplyAdapter = new VesuMultiplyAdapter({
@@ -965,6 +1405,7 @@ function getLooperSettings(
       { asset: wbtcToken, isDebt: false },
       { asset: usdcToken, isDebt: true },
     ],
+    minimumVesuMovementAmount: minimumVesuMovementAmount ?? 5, //5 usdc
   });
 
   const unusedBalanceAdapter = new UnusedBalanceAdapter({
@@ -1007,7 +1448,6 @@ function getLooperSettings(
   vaultSettings.leafAdapters.push(() => extendedAdapter.getSwapFromLegacyLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getDepositLeaf());
   vaultSettings.leafAdapters.push(() => avnuAdapter.getWithdrawLeaf());
-  // Doubt here, should this be usdcToken.address, or wbtcToken.address?
   vaultSettings.leafAdapters.push(
     commonAdapter
       .getApproveAdapter(
@@ -1078,11 +1518,11 @@ export default function VaultDescription(
 }
 
 const re7UsdcPrimeDevansh: VesuExtendedStrategySettings = {
-  vaultAddress: ContractAddr.from("0x520a2e945dd0762e5284fc1b012f62ca04e238e105eb362d5e0ce208928729d"),
-  manager: ContractAddr.from("0x6abe24d31cbc16d7c4acb2421a826f96273e225b4a2d168d91e65123da0bfb9"),
-  vaultAllocator: ContractAddr.from("0x6e4f716e22efb164ee4a831233e513f45396ad3be4cff3c07386be0226febed"),
-  redeemRequestNFT: ContractAddr.from("0x66060e1874e05506b18e6029188ec49bf231a411ad57642311bbdf3cb22e5f"),
-  aumOracle: ContractAddr.from("0x301d883b9b45c76132638e39326b3f464c492599623263d405ec0df991e27ab"),
+  vaultAddress: ContractAddr.from("0x058905be22d6a81792df79425dc9641cf3e1b77f36748631b7d7e5d713a32b55"),
+  manager: ContractAddr.from("0x02648d703783feb2d967cf0520314cb5aa800d69a9426f3e3b317395af44de16"),
+  vaultAllocator: ContractAddr.from("0x07d533c838eab6a4d854dd3aea96a55993fccd35821921970d00bde946b63b6f"),
+  redeemRequestNFT: ContractAddr.from("0x01ef91f08fb99729c00f82fc6e0ece37917bcc43952596c19996259dc8adbbba"),
+  aumOracle: ContractAddr.from("0x030b6acfec162f5d6e72b8a4d2798aedce78fb39de78a8f549f7cd277ae8bc8d"),
   leafAdapters: [],
   adapters: [],
   targetHealthFactor: 1.4,
@@ -1096,17 +1536,18 @@ const re7UsdcPrimeDevansh: VesuExtendedStrategySettings = {
   ),
   borrowable_assets: [Global.getDefaultTokens().find(token => token.symbol === "WBTC")!],
   minimumWBTCDifferenceForAvnuSwap: MINIMUM_WBTC_DIFFERENCE_FOR_AVNU_SWAP,
+  walletAddress: WALLET_ADDRESS,
 }
 
-export const VesuExtendedTestStrategies = (extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number): IStrategyMetadata<VesuExtendedStrategySettings>[] => {
+export const VesuExtendedTestStrategies = (extendedBackendReadUrl: string, extendedBackendWriteUrl: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number): IStrategyMetadata<VesuExtendedStrategySettings>[] => {
   return [
-    getStrategySettingsVesuExtended('WBTC', 'USDC', re7UsdcPrimeDevansh, false, false, extendedBackendUrl, extendedApiKey, vaultIdExtended),
+    getStrategySettingsVesuExtended('WBTC', 'USDC', re7UsdcPrimeDevansh, false, false, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing),
   ]
 }
 
 
 
-function getStrategySettingsVesuExtended(lstSymbol: string, underlyingSymbol: string, addresses: VesuExtendedStrategySettings, isPreview: boolean = false, isLST: boolean, extendedBackendUrl: string, extendedApiKey: string, vaultIdExtended: number): IStrategyMetadata<VesuExtendedStrategySettings> {
+function getStrategySettingsVesuExtended(lstSymbol: string, underlyingSymbol: string, addresses: VesuExtendedStrategySettings, isPreview: boolean = false, isLST: boolean, extendedBackendReadUrl: string, extendedBackendWriteUrl: string, vaultIdExtended: number, minimumExtendedMovementAmount: number, minimumVesuMovementAmount: number, minimumExtendedRetriesDelayForOrderStatus: number, minimumExtendedPriceDifferenceForSwapOpen: number, maximumExtendedPriceDifferenceForSwapClosing: number): IStrategyMetadata<VesuExtendedStrategySettings> {
   return {
     name: `Extended Test ${underlyingSymbol}`,
     description: getDescription(lstSymbol, underlyingSymbol),
@@ -1114,7 +1555,7 @@ function getStrategySettingsVesuExtended(lstSymbol: string, underlyingSymbol: st
     launchBlock: 0,
     type: 'Other',
     depositTokens: [Global.getDefaultTokens().find(token => token.symbol === underlyingSymbol)!],
-    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7USDCPrime, extendedBackendUrl, extendedApiKey, vaultIdExtended),
+    additionalInfo: getLooperSettings(lstSymbol, underlyingSymbol, addresses, VesuPools.Re7USDCPrime, extendedBackendReadUrl, extendedBackendWriteUrl, vaultIdExtended, minimumExtendedMovementAmount, minimumVesuMovementAmount, minimumExtendedRetriesDelayForOrderStatus, minimumExtendedPriceDifferenceForSwapOpen, maximumExtendedPriceDifferenceForSwapClosing),
     risk: {
       riskFactor: _riskFactor,
       netRisk: